Comparison with Azure (Farmer F#) to AWS (FsCDK)

This guide helps developers familiar with Farmer (the F# DSL for Azure) transition to FsCDK for AWS infrastructure.

Philosophy

Both Farmer and FsCDK share similar goals:

• Type Safety: Catch configuration errors at compile time
• Security by Default: Follow cloud provider best practices
• Composability: Build reusable infrastructure components
• F# Idioms: Use computation expressions and functional patterns

Conceptual Mapping

Azure → AWS Service Mapping

Mapping of services

Storage

Compute

Databases

Networking

Security & Identity

Messaging & Events

Monitoring & Observability

Content Delivery

Container Registry

Orchestration & Workflow

Developer Tools & Integration

Certificates

Code Examples

Storage: Blob Storage → S3

Farmer (Azure Blob Storage):

#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 Farmer
open Farmer.Builders

let storage = storageAccount {
    name "mystorageaccount"
    sku Storage.Sku.Standard_LRS
}

let deployment = arm {
    location Location.EastUS
    add_resource storage
}

FsCDK (AWS S3):

open FsCDK
open Amazon.CDK.AWS.S3

stack "MyStack" {
    s3Bucket "my-bucket" {
        versioned true
        encryption BucketEncryption.S3_MANAGED
    }
}

Compute: Azure Functions → Lambda

Farmer (Azure Functions):

let myFunction = functions {
    name "myfunctionapp"
    service_plan_name "myserviceplan"
    runtime_stack Runtime.DotNet80
    operating_system OS.Linux

    setting "StorageConnection" storageConnection
}

FsCDK (AWS Lambda):

open Amazon.CDK.AWS.Lambda

let myLambdaFunction =
    lambda "my-function" {
        handler "MyApp::MyApp.Handler::FunctionHandler"
        runtime Runtime.DOTNET_8
        code "./publish"
        memorySize 512
        timeout 30.0
        environment [ "KEY", "value" ]
    }

Database: Cosmos DB → DynamoDB

Farmer (Cosmos DB):

let cosmos = cosmosDb {
    name "mycosmosdb"
    account_name "mycosmosaccount"
    throughput 400<RUs>
    failover_policy NoFailover
    consistency_policy Eventual
}

FsCDK (DynamoDB):

open Amazon.CDK.AWS.DynamoDB

let myDynamoTable =
    table "my-table" {
        partitionKey "id" AttributeType.STRING
        sortKey "timestamp" AttributeType.NUMBER
        billingMode BillingMode.PAY_PER_REQUEST
    }

Networking: VNet → VPC

Farmer (Azure VNet):

let vnet = vnet {
    name "myvnet"
    add_address_spaces [ "10.0.0.0/16" ]

    add_subnets [
        subnet {
            name "webapp-subnet"
            prefix "10.0.1.0/24"
        }
        subnet {
            name "db-subnet"
            prefix "10.0.2.0/24"
        }
    ]
}

FsCDK (AWS VPC, "Virtual Private Cloud"):

open Amazon.CDK.AWS.EC2

let myVirtualPrivateCloud =
    vpc "my-vpc" {
        cidr "10.0.0.0/16"
        maxAzs 2
        natGateways 1
    }

Messaging: Event Hub → Kinesis

Farmer (Azure Event Hub):

let eventHub = eventHub {
    name "myeventhub"
    namespace_name "myeventhubnamespace"
    sku EventHub.Sku.Standard
    partition_count 4
    message_retention 7<Days>
}

FsCDK (AWS Kinesis Data Streams):

open Amazon.CDK
open Amazon.CDK.AWS.Kinesis

let myStream =
    kinesisStream "MyStream" {
        streamName "my-data-stream"
        shardCount 4
        retentionPeriod (Duration.Hours 168.) // 7 days
        encryption StreamEncryption.KMS
    }

For detailed Kinesis examples, see the Kinesis Streams Guide.

Container Orchestration: AKS → EKS

Farmer (Azure Kubernetes Service):

let aks = aks {
    name "myakscluster"
    service_principal_use_msi Enabled
    dns_prefix "myaks"

    add_agent_pools [
        agentPool {
            name "nodepool1"
            count 3
            vm_size "Standard_DS2_v2"
        }
    ]
}

FsCDK (AWS Elastic Kubernetes Service):

open Amazon.CDK.AWS.EKS

let cluster =
    eksCluster "MyEKSCluster" {
        version KubernetesVersion.V1_28
        defaultCapacity 0

        addNodegroupCapacity (
            "NodeGroup",
            NodegroupOptions(
                InstanceTypes = [| InstanceType.Of(InstanceClass.BURSTABLE3, InstanceSize.MEDIUM) |],
                MinSize = 1.,
                MaxSize = 5.,
                DesiredSize = 3.
            )
        )
    }

For comprehensive EKS examples, see the EKS Guide.

Security: Managed Identity → IAM Role

Farmer (Managed Identity):

let identity = createUserAssignedIdentity "myidentity"

let webApp = webApp {
    name "mywebapp"
    add_identity identity
}

FsCDK (IAM Role):

open FsCDK

// Create execution role for Lambda
let role = IAM.createLambdaExecutionRole "my-function" true

// Or create a custom role 
let customRole = IAM.createRole "lambda.amazonaws.com" "my-custom-role"

Key Differences

1. Stack Model

Farmer:

• Uses ARM templates
• Deployment at resource group level
• Single region per deployment

FsCDK:

• Uses AWS CloudFormation
• Stack-based deployment
• Multi-region support

2. Naming Conventions

Farmer:

• Resource names are globally unique or scoped to resource group
• Naming restrictions vary by service

FsCDK:

• Most resources autogenerate unique names
• Logical IDs separate from physical names
• More flexible naming

3. Security Defaults

Farmer:

• Follows Azure best practices
• Managed identities for authentication
• Network security groups

FsCDK:

• Follows AWS Well-Architected Framework
• IAM roles and policies
• Security groups and NACLs

4. Deployment Process

Farmer:

# Generate ARM template
dotnet run

# Deploy with Azure CLI
az deployment group create \
    --resource-group mygroup \
    --template-file output.json

FsCDK:

# Synthesize CloudFormation
cdk synth

# Deploy with CDK
cdk deploy

Migration Checklist

• [ ] Map Azure services to AWS equivalents
• [ ] Update authentication (Managed Identity → IAM Role)
• [ ] Adapt networking concepts (VNet → VPC, NSG → Security Group)
• [ ] Modify storage patterns (Blob → S3, Queue → SQS)
• [ ] Update database configurations (Cosmos → DynamoDB, SQL → RDS)
• [ ] Migrate event streaming (Event Hub → Kinesis)
• [ ] Adapt container orchestration (AKS → EKS)
• [ ] Review security defaults and adjust as needed
• [ ] Test with cdk synth before deploying
• [ ] Update CI/CD pipelines for AWS deployment

Common Patterns

Environment Configuration

Farmer:

let env = Environment.GetEnvironmentVariable

let config = {
    Environment = env "ENVIRONMENT" |> Option.defaultValue "dev"
    Location = Location.EastUS
}

FsCDK:

open Amazon.CDK

// Use environment variables or defaults for AWS account/region
let accountId =
    System.Environment.GetEnvironmentVariable("CDK_DEFAULT_ACCOUNT")
    |> Option.ofObj
    |> Option.defaultValue "000000000000"

let regionName =
    System.Environment.GetEnvironmentVariable("CDK_DEFAULT_REGION")
    |> Option.ofObj
    |> Option.defaultValue "us-east-1"

stack "MyStack" {
    env (
        environment {
            account accountId
            region regionName
        }
    )
}

Resource Composition

Farmer:

let storage = storageAccount { name "storage" }
let webApp = webApp {
    name "webapp"
    depends_on storage
}

let deployment = arm {
    add_resources [ storage; webApp ]
}

FsCDK:

stack "MyStack" {
    let bucket = s3Bucket "my-bucket" { () }

    lambda "my-function" {
        handler "index.handler"
        runtime Runtime.NODEJS_18_X
        code "./code"
    // Lambda can read from bucket (configure IAM separately)
    }
}

Tagging

Farmer:

let deployment = arm {
    add_resource myResource
    add_tags [ "Environment", "Production"; "Owner", "Team" ]
}

FsCDK:

open FsCDK

stack "MyStack" {
    Tags.tagStack this "my-project" "production" (Some "team@example.com")

    // Resources...
}

Best Practices

1. Start Small

Begin with a single service or component, test thoroughly, then expand.

2. Use Existing Patterns

Study the examples in /examples directory for common patterns.

3. Security First

Review FsCDK's security defaults and adjust for your requirements.

4. Test Locally

Use cdk synth to generate CloudFormation templates and review them before deploying.

5. Leverage Escape Hatches

When FsCDK builders don't cover your use case, access underlying CDK constructs.

Resources

• FsCDK Documentation
• FsCDK Examples
• Kinesis Streams Guide
• EKS Kubernetes Guide
• AWS CDK Documentation
• Farmer Documentation
• AWS Well-Architected Framework

Getting Help

• GitHub Issues: Bug reports and feature requests
• GitHub Discussions: Questions and community support
• Stack Overflow: Tag questions with fscdk or aws-cdk

Welcome to FsCDK! We're excited to have Farmer users in the community. 🎉