Getting Started with FsCDK - Extended Features

Welcome to the extended FsCDK! This guide will help you understand the new features and how to use them effectively.

What's New?

FsCDK now includes builders for:

• VPC & Networking - Secure, multi-AZ virtual private clouds
• RDS PostgreSQL - Managed databases with automated backups
• CloudFront - Global CDN for fast content delivery
• Cognito - User authentication with MFA support

All following AWS Well-Architected Framework best practices!

Quick Start Examples

1. Create a Secure VPC

#r "../src/bin/Release/net8.0/publish/Amazon.JSII.Runtime.dll"
#r "../src/bin/Release/net8.0/publish/Constructs.dll"
#r "../src/bin/Release/net8.0/publish/Amazon.CDK.Lib.dll"
#r "../src/bin/Release/net8.0/publish/System.Text.Json.dll"
#r "../src/bin/Release/net8.0/publish/FsCDK.dll"

open FsCDK

vpc "MyVpc" {
    maxAzs 2 // Multi-AZ for high availability
    natGateways 1 // Cost-optimized
    cidr "10.0.0.0/16" // IP address range
}

What you get:

• 2 public subnets (one per AZ)
• 2 private subnets with NAT gateway access
• DNS hostnames and support enabled
• Best practices baked in!

2. Add a PostgreSQL Database

Here's how to add a PostgreSQL database (shown in full stack example below):

rdsInstance "MyDatabase" {
    vpc myVpc
    postgresEngine // PostgreSQL 15
    instanceType (InstanceType.Of(InstanceClass.BURSTABLE3, InstanceSize.SMALL))
    allocatedStorage 20

    // Automatic best practices:
    // Encrypted storage
    // 7-day automated backups
    // Auto minor version upgrades
    // Private subnet placement

    multiAz true // High availability
    databaseName "myapp"
}

What you get:

• Encrypted database in private subnet
• Automated backups with 7-day retention
• Multi-AZ replication for HA
• Not publicly accessible (secure!)

3. Set Up User Authentication

open Amazon.CDK.AWS.Cognito

stack "MyApp" {
    // Create user pool
    let! myUserPool =
        userPool "MyUserPool" {
            signInWithEmail // Users sign in with email
            selfSignUpEnabled true // Allow self-registration
            mfa Mfa.OPTIONAL // Users can enable MFA

        // Automatic best practices:
        // Strong password policy (8+ chars, mixed case, digits, symbols)
        // Email verification required
        // Account recovery via email
        }

    // Create an app client
    userPoolClient "MyAppClient" {
        userPool myUserPool
        generateSecret false // For web/mobile apps
    }

// Automatic best practices:
// SRP authentication flow
// Prevents user existence errors
// Reasonable token expiration times
}

What you get:

• Secure authentication with strong passwords
• Email verification out of the box
• MFA support for enhanced security
• Industry-standard OAuth flows

4. Add a CDN for Fast Delivery

What you get:

• Global content delivery network
• Modern protocols (HTTP/2, IPv6)
• Secure by default (TLS 1.2+)
• Cost-optimized for common use cases

Complete Application Stack

FsCDK App structure showing multiple stacks with constructs organized hierarchically. Each stack contains AWS resources (S3, Lambda, EC2) managed by your infrastructure-as-code heroes!

Here's how to combine everything into a production-ready stack:

open Amazon.CDK.AWS.S3
open Amazon.CDK.AWS.Lambda

Best Practices Baked In

FsCDK automatically applies AWS best practices:

Security

• Encryption enabled by default (S3, RDS)
• Security groups deny all by default
• Strong password policies
• Private subnet placement for databases
• No public database access

High Availability

• Multi-AZ VPC configuration
• Multi-AZ database replication
• Automated backups (7-day retention)
• Global CDN distribution

Cost Optimization

• Right-sized instance defaults (t3.micro)
• Single NAT gateway for dev/test
• Regional CDN pricing (PriceClass100)
• Pay-per-request database options

Performance

• HTTP/2 enabled for CDN
• IPv6 support
• Proper subnet segmentation
• Monitoring capabilities built-in

Common Patterns

Pattern 1: Web Application with Auth

stack "WebApp" {
    vpc "WebVpc" { () }

    userPool "Users" {
        signInWithEmail
        selfSignUpEnabled true
    }

    lambda "Api" {
        runtime Runtime.DOTNET_8
        handler "Api::Handler"
        code "./publish"
    }

    bucket "Assets" { versioned true }
}

Pattern 2: Data Processing Pipeline

stack "DataPipeline" {
    let! myVpc = vpc "DataVpc" { () }

    rdsInstance "DataWarehouse" {
        vpc myVpc
        postgresEngine
        multiAz true
    }

    lambda "Processor" {
        runtime Runtime.DOTNET_8
        handler "Processor::Handler"
        code "./publish"
        timeout 300.0 // 5 minutes for data processing
        memorySize 1024 // More memory for processing
    }

    bucket "DataLake" {
        versioned true
    // lifecycleRules [ /* ... */ ]
    }
}

Pattern 3: Serverless API with CDN

open Amazon.CDK.AWS.DynamoDB

Migration from Existing FsCDK

Good news! No breaking changes! Your existing code continues to work:

// Your existing code still works!
stack "MyStack" {
    lambda "MyFunction" {
        runtime Runtime.DOTNET_8
        handler "index.handler"
        code "./lambda"
    }

    table "MyTable" { partitionKey "id" AttributeType.STRING }
}

// Just add new features when you need them
stack "EnhancedStack" {
    // Existing services
    lambda "MyFunction" {
        runtime Runtime.DOTNET_8
        handler "index.handler"
        code "./lambda"
    }

    // New services
    let! myVpc = vpc "MyVpc" { () }

    rdsInstance "MyDB" {
        vpc myVpc
        postgresEngine
    }

    userPool "MyAuth" { signInWithEmail }
}

Learning Resources

1. Examples: See Multi-Tier Example for a complete application
2. Security: Read IAM Best Practices for security guidance
3. API Docs: Check XML documentation comments in code
4. AWS Docs: AWS CDK Documentation

Next Steps

1. Install FsCDK: dotnet add package FsCDK
2. Create your first VPC: vpc "MyVpc" { }
3. Add a database: rdsInstance "MyDB" { vpc myVpc; postgresEngine }
4. Deploy: cdk deploy
5. Monitor in AWS Console

Getting Help

• Read the examples in the docs
• Check the test files for usage patterns
• Ask questions in GitHub Issues
• Reference AWS CDK documentation

Tips for Success

1. Start Small: Begin with a simple VPC or database
2. Use Defaults: FsCDK defaults are production-ready
3. Review Generated Templates: Run cdk synth to see CloudFormation
4. Test Incrementally: Deploy small changes frequently
5. Follow Best Practices: Read the IAM best practices guide

Cost Management

Monitor your costs:

• Use aws ce get-cost-and-usage CLI command
• Set up AWS Budgets
• Review the cost estimates in examples
• Start with smaller instance types
• Use t3.micro for development

Troubleshooting

Build Errors

# Clean and rebuild
dotnet clean
dotnet build

Deployment Issues

# Verify CDK bootstrap
cdk bootstrap aws://ACCOUNT/REGION

# Check diff before deploying
cdk diff

# Deploy with verbose output
cdk deploy --verbose

Resource Already Exists

# Import existing resources
cdk import

# Or use different names
vpc "MyVpc-v2" { ... }

What's Available?

FsCDK supports 30+ AWS services including:

• Load Balancers: Application Load Balancer (ALB), Network Load Balancer (NLB)
• DNS & Certificates: Route53 hosted zones, private zones, A records, Certificate Manager
• Containers: ECS/Fargate task definitions and services, ECR repositories, EKS clusters
• Databases: RDS (PostgreSQL, MySQL, etc.), DynamoDB, DocumentDB, ElastiCache
• Messaging: SNS, SQS, Kinesis streams, EventBridge
• Monitoring: CloudWatch alarms, dashboards, log groups, metric filters, X-Ray, Synthetics
• Security: KMS encryption, Secrets Manager, IAM roles and policies, OIDC providers
• API & Integration: API Gateway (REST & HTTP), AppSync GraphQL, Step Functions
• Storage & CDN: S3, CloudFront distributions
• Compute: Lambda functions with Powertools, App Runner, Elastic Beanstalk

See the full list of supported services in the documentation.

Ready to build secure, scalable infrastructure with F#? Let's go!