diff --git a/cdkExample/.gitignore b/cdkExample/.gitignore new file mode 100644 index 0000000..92fe1ec --- /dev/null +++ b/cdkExample/.gitignore @@ -0,0 +1,19 @@ +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# go.sum should be committed +!go.sum + +# CDK asset staging directory +.cdk.staging +cdk.out diff --git a/cdkExample/README.md b/cdkExample/README.md new file mode 100644 index 0000000..79e5c45 --- /dev/null +++ b/cdkExample/README.md @@ -0,0 +1,12 @@ +# Welcome to your CDK Go project! + +This is a blank project for CDK development with Go. + +The `cdk.json` file tells the CDK toolkit how to execute your app. + +## Useful commands + + * `cdk deploy` deploy this stack to your default AWS account/region + * `cdk diff` compare deployed stack with current state + * `cdk synth` emits the synthesized CloudFormation template + * `go test` run unit tests diff --git a/cdkExample/cdk.json b/cdkExample/cdk.json new file mode 100644 index 0000000..444ab81 --- /dev/null +++ b/cdkExample/cdk.json @@ -0,0 +1,61 @@ +{ + "app": "go mod download && go run cdk_example.go", + "watch": { + "include": [ + "**" + ], + "exclude": [ + "README.md", + "cdk*.json", + "go.mod", + "go.sum", + "**/*test.go" + ] + }, + "context": { + "@aws-cdk/aws-lambda:recognizeLayerVersion": true, + "@aws-cdk/core:checkSecretUsage": true, + "@aws-cdk/core:target-partitions": [ + "aws", + "aws-cn" + ], + "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true, + "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true, + "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": true, + "@aws-cdk/aws-iam:minimizePolicies": true, + "@aws-cdk/core:validateSnapshotRemovalPolicy": true, + "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true, + "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true, + "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true, + "@aws-cdk/aws-apigateway:disableCloudWatchRole": true, + "@aws-cdk/core:enablePartitionLiterals": true, + "@aws-cdk/aws-events:eventsTargetQueueSameAccount": true, + "@aws-cdk/aws-iam:standardizedServicePrincipals": true, + "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true, + "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": true, + "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true, + "@aws-cdk/aws-route53-patters:useCertificate": true, + "@aws-cdk/customresources:installLatestAwsSdkDefault": false, + "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true, + "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": true, + "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": true, + "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": true, + "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": true, + "@aws-cdk/aws-redshift:columnId": true, + "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": true, + "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true, + "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true, + "@aws-cdk/aws-kms:aliasNameRef": true, + "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true, + "@aws-cdk/core:includePrefixInUniqueNameGeneration": true, + "@aws-cdk/aws-efs:denyAnonymousAccess": true, + "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": true, + "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": true, + "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": true, + "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": true, + "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": true, + "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": true, + "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": true, + "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": true + } +} diff --git a/cdkExample/cdk_example.go b/cdkExample/cdk_example.go new file mode 100644 index 0000000..4f0e41f --- /dev/null +++ b/cdkExample/cdk_example.go @@ -0,0 +1,86 @@ +package main + +import ( + "github.com/aws/aws-cdk-go/awscdk/v2" + "github.com/aws/aws-cdk-go/awscdk/v2/awsapigateway" + "github.com/aws/aws-cdk-go/awscdk/v2/awsdynamodb" + "github.com/aws/aws-cdk-go/awscdk/v2/awslambda" + "github.com/aws/constructs-go/constructs/v10" + "github.com/aws/jsii-runtime-go" +) + +type Take2GoCdkStackProps struct { + awscdk.StackProps +} + +func NewTake2GoCdkStack(scope constructs.Construct, id string, props *Take2GoCdkStackProps) awscdk.Stack { + var sprops awscdk.StackProps + if props != nil { + sprops = props.StackProps + } + stack := awscdk.NewStack(scope, &id, &sprops) + + table := awsdynamodb.NewTable(stack, jsii.String("myUserTable2"), &awsdynamodb.TableProps{ + PartitionKey: &awsdynamodb.Attribute{ + Name: jsii.String("username"), + Type: awsdynamodb.AttributeType_STRING, + }, + TableName: jsii.String("userTable2"), + }) + + // define our lambda here + myFunction := awslambda.NewFunction(stack, jsii.String("myLambdaFunction2"), &awslambda.FunctionProps{ + Runtime: awslambda.Runtime_PROVIDED_AL2023(), + Code: awslambda.AssetCode_FromAsset(jsii.String("lambda/function.zip"), nil), + Handler: jsii.String("main"), + }) + + // define our api gateway + api := awsapigateway.NewRestApi(stack, jsii.String("myAPIGateway2"), &awsapigateway.RestApiProps{ + DefaultCorsPreflightOptions: &awsapigateway.CorsOptions{ + AllowHeaders: jsii.Strings("Content-Type", "Authorization"), + AllowMethods: jsii.Strings("GET", "POST", "DELETE", "PUT", "OPTIONS"), + AllowOrigins: jsii.Strings("*"), + }, + DeployOptions: &awsapigateway.StageOptions{ + LoggingLevel: awsapigateway.MethodLoggingLevel_INFO, + }, + EndpointConfiguration: &awsapigateway.EndpointConfiguration{ + Types: &[]awsapigateway.EndpointType{awsapigateway.EndpointType_REGIONAL}, + }, + }) + + // integrate the routes + methods to this endpoint + integration := awsapigateway.NewLambdaIntegration(myFunction, nil) + + registerRoute := api.Root().AddResource(jsii.String("register"), nil) + registerRoute.AddMethod(jsii.String("POST"), integration, nil) + + loginRoute := api.Root().AddResource(jsii.String("login"), nil) + loginRoute.AddMethod(jsii.String("POST"), integration, nil) + + protectedRoute := api.Root().AddResource(jsii.String("protected"), nil) + protectedRoute.AddMethod(jsii.String("GET"), integration, nil) + + table.GrantReadWriteData(myFunction) + + return stack +} + +func main() { + defer jsii.Close() + + app := awscdk.NewApp(nil) + + NewTake2GoCdkStack(app, "Take2GoCdkStack", &Take2GoCdkStackProps{ + awscdk.StackProps{ + Env: env(), + }, + }) + + app.Synth(nil) +} + +func env() *awscdk.Environment { + return nil +} diff --git a/cdkExample/cdk_example_test.go b/cdkExample/cdk_example_test.go new file mode 100644 index 0000000..09be4c6 --- /dev/null +++ b/cdkExample/cdk_example_test.go @@ -0,0 +1,26 @@ +package main + +// import ( +// "testing" + +// "github.com/aws/aws-cdk-go/awscdk/v2" +// "github.com/aws/aws-cdk-go/awscdk/v2/assertions" +// "github.com/aws/jsii-runtime-go" +// ) + +// example tests. To run these tests, uncomment this file along with the +// example resource in cdk_example_test.go +// func TestCdkExampleStack(t *testing.T) { +// // GIVEN +// app := awscdk.NewApp(nil) + +// // WHEN +// stack := NewCdkExampleStack(app, "MyStack", nil) + +// // THEN +// template := assertions.Template_FromStack(stack, nil) + +// template.HasResourceProperties(jsii.String("AWS::SQS::Queue"), map[string]interface{}{ +// "VisibilityTimeout": 300, +// }) +// } diff --git a/cdkExample/go.mod b/cdkExample/go.mod new file mode 100644 index 0000000..f41c9a6 --- /dev/null +++ b/cdkExample/go.mod @@ -0,0 +1,28 @@ +module cdk_example + +go 1.18 + +require ( + github.com/aws/aws-cdk-go/awscdk/v2 v2.125.0 + github.com/aws/constructs-go/constructs/v10 v10.3.0 + github.com/aws/jsii-runtime-go v1.94.0 +) + +require ( + github.com/Masterminds/semver/v3 v3.2.1 // indirect + github.com/aws/aws-lambda-go v1.46.0 // indirect + github.com/aws/aws-sdk-go v1.50.24 // indirect + github.com/cdklabs/awscdk-asset-awscli-go/awscliv1/v2 v2.2.202 // indirect + github.com/cdklabs/awscdk-asset-kubectl-go/kubectlv20/v2 v2.1.2 // indirect + github.com/cdklabs/awscdk-asset-node-proxy-agent-go/nodeproxyagentv6/v2 v2.0.1 // indirect + github.com/fatih/color v1.16.0 // indirect + github.com/golang-jwt/jwt/v5 v5.2.0 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/mattn/go-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/yuin/goldmark v1.4.13 // indirect + golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect + golang.org/x/mod v0.14.0 // indirect + golang.org/x/sys v0.14.0 // indirect + golang.org/x/tools v0.16.1 // indirect +) diff --git a/cdkExample/go.sum b/cdkExample/go.sum new file mode 100644 index 0000000..67ff2c9 --- /dev/null +++ b/cdkExample/go.sum @@ -0,0 +1,58 @@ +github.com/Masterminds/semver/v3 v3.2.1 h1:RN9w6+7QoMeJVGyfmbcgs28Br8cvmnucEXnY0rYXWg0= +github.com/Masterminds/semver/v3 v3.2.1/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ= +github.com/aws/aws-cdk-go/awscdk/v2 v2.125.0 h1:UJCNM2NmyOlDuBoDDVQwHGjpqz0MIR+4nIlWAwwlYfM= +github.com/aws/aws-cdk-go/awscdk/v2 v2.125.0/go.mod h1:TpmJwOnoajvRtwnLlJoxEoppb9sVoCLfPGLdgoTDH7o= +github.com/aws/aws-lambda-go v1.46.0 h1:UWVnvh2h2gecOlFhHQfIPQcD8pL/f7pVCutmFl+oXU8= +github.com/aws/aws-lambda-go v1.46.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A= +github.com/aws/aws-sdk-go v1.50.24 h1:3o2Pg7mOoVL0jv54vWtuafoZqAeEXLhm1tltWA2GcEw= +github.com/aws/aws-sdk-go v1.50.24/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/constructs-go/constructs/v10 v10.3.0 h1:LsjBIMiaDX/vqrXWhzTquBJ9pPdi02/H+z1DCwg0PEM= +github.com/aws/constructs-go/constructs/v10 v10.3.0/go.mod h1:GgzwIwoRJ2UYsr3SU+JhAl+gq5j39bEMYf8ev3J+s9s= +github.com/aws/jsii-runtime-go v1.94.0 h1:VuVDx0xL2gbsJthUMfP+SwAXGkSEQd0GKm0ydZ8xga8= +github.com/aws/jsii-runtime-go v1.94.0/go.mod h1:tQOz8aAMzM2XsRUDsnUgPvGcHNAzR/xtH0OgeM0lTWo= +github.com/cdklabs/awscdk-asset-awscli-go/awscliv1/v2 v2.2.202 h1:VixXB9DnHN8oP7pXipq8GVFPjWCOdeNxIaS/ZyUwTkI= +github.com/cdklabs/awscdk-asset-awscli-go/awscliv1/v2 v2.2.202/go.mod h1:iPUti/SWjA3XAS3CpnLciFjS8TN9Y+8mdZgDfSgcyus= +github.com/cdklabs/awscdk-asset-kubectl-go/kubectlv20/v2 v2.1.2 h1:k+WD+6cERd59Mao84v0QtRrcdZuuSMfzlEmuIypKnVs= +github.com/cdklabs/awscdk-asset-kubectl-go/kubectlv20/v2 v2.1.2/go.mod h1:CvFHBo0qcg8LUkJqIxQtP1rD/sNGv9bX3L2vHT2FUAo= +github.com/cdklabs/awscdk-asset-node-proxy-agent-go/nodeproxyagentv6/v2 v2.0.1 h1:MBBQNKKPJ5GArbctgwpiCy7KmwGjHDjUUH5wEzwIq8w= +github.com/cdklabs/awscdk-asset-node-proxy-agent-go/nodeproxyagentv6/v2 v2.0.1/go.mod h1:/2WiXEft9s8ViJjD01CJqDuyJ8HXBjhBLtK5OvJfdSc= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= +github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= +github.com/golang-jwt/jwt/v5 v5.2.0 h1:d/ix8ftRUorsN+5eMIlF4T6J8CAt9rch3My2winC1Jw= +github.com/golang-jwt/jwt/v5 v5.2.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 h1:VLliZ0d+/avPrXXH+OakdXhpJuEoBZuwh1m2j7U6Iug= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.14.0 h1:Vz7Qs629MkJkGyHxUlRHizWJRG2j8fbQKjELVSNhy7Q= +golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.16.1 h1:TLyB3WofjdOEepBHAU20JdNC1Zbg87elYofWYAY5oZA= +golang.org/x/tools v0.16.1/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/cdkExample/go.work b/cdkExample/go.work new file mode 100644 index 0000000..ac8293f --- /dev/null +++ b/cdkExample/go.work @@ -0,0 +1,5 @@ +go 1.21.3 + +use ./ + +use ./lambda diff --git a/cdkExample/go.work.sum b/cdkExample/go.work.sum new file mode 100644 index 0000000..2315677 --- /dev/null +++ b/cdkExample/go.work.sum @@ -0,0 +1,25 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550 h1:ObdrDkeb4kJdCP557AjRjq69pTHfNouLtWZG7j9rPN8= +golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c= +golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= +golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k= +golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/cdkExample/lambda/.env b/cdkExample/lambda/.env new file mode 100644 index 0000000..da2da21 --- /dev/null +++ b/cdkExample/lambda/.env @@ -0,0 +1 @@ +JWT_SECRET="test" \ No newline at end of file diff --git a/cdkExample/lambda/Makefile b/cdkExample/lambda/Makefile new file mode 100644 index 0000000..21ad5c9 --- /dev/null +++ b/cdkExample/lambda/Makefile @@ -0,0 +1,3 @@ +build: + @GOOS=linux GOARCH=amd64 go build -o bootstrap + @zip function.zip bootstrap \ No newline at end of file diff --git a/cdkExample/lambda/api/api.go b/cdkExample/lambda/api/api.go new file mode 100644 index 0000000..0a86b4c --- /dev/null +++ b/cdkExample/lambda/api/api.go @@ -0,0 +1,123 @@ +package api + +// This is going to be the "Handler Layer" +// This will process the requests and call our DB layer + +import ( + "encoding/json" + "fmt" + "lambda-func/database" + "lambda-func/types" + "net/http" + + "github.com/aws/aws-lambda-go/events" +) + +type ApiHandler struct { + dbStore database.UserStore +} + +func NewApiHandler(dbStore database.UserStore) ApiHandler { + return ApiHandler{ + dbStore: dbStore, + } +} + +// The handler our lambda will route to when we need to register our new users + +func (api *ApiHandler) RegisterUser(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + var registerUser types.RegisterUser + + err := json.Unmarshal([]byte(request.Body), ®isterUser) + if err != nil { + return events.APIGatewayProxyResponse{ + Body: "Invalid Request", + StatusCode: http.StatusBadRequest, + }, err + } + + if registerUser.Username == "" || registerUser.Password == "" { + return events.APIGatewayProxyResponse{ + Body: "Invalid Request", + StatusCode: http.StatusBadRequest, + }, fmt.Errorf("register user request fields cannot be empty") + } + + // We need to check if a user wit hthe same username already exists in our DB + doesUserExist, err := api.dbStore.DoesUserExist(registerUser.Username) + if err != nil { + return events.APIGatewayProxyResponse{ + Body: "Internal server error", + StatusCode: http.StatusInternalServerError, + }, fmt.Errorf("checking if user exists error %w", err) + } + + if doesUserExist { + return events.APIGatewayProxyResponse{ + Body: "User already exists", + StatusCode: http.StatusConflict, + }, nil + } + + user, err := types.NewUser(registerUser) + if err != nil { + return events.APIGatewayProxyResponse{ + Body: "Internal Server error", + StatusCode: http.StatusConflict, + }, fmt.Errorf("error hashing user password %w", err) + } + + // we know that this user does not exist + err = api.dbStore.InsertUser(user) + if err != nil { + return events.APIGatewayProxyResponse{ + Body: "Internal server error", + StatusCode: http.StatusInternalServerError, + }, fmt.Errorf("error inserting user into the database %w", err) + } + + return events.APIGatewayProxyResponse{ + Body: "Success", + StatusCode: http.StatusOK, + }, nil +} + +func (api *ApiHandler) LoginUser(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + type LoginRequest struct { + Username string `json:"username"` + Password string `json:"password"` + } + + var loginRequest LoginRequest + + err := json.Unmarshal([]byte(request.Body), &loginRequest) + if err != nil { + return events.APIGatewayProxyResponse{ + Body: "invalid request", + StatusCode: http.StatusBadRequest, + }, err + } + + user, err := api.dbStore.GetUser(loginRequest.Username) + if err != nil { + return events.APIGatewayProxyResponse{ + Body: "Internal server error", + StatusCode: http.StatusInternalServerError, + }, err + } + + if !types.ValidatePassword(user.PasswordHash, loginRequest.Password) { + return events.APIGatewayProxyResponse{ + Body: "Invalid login credentials", + StatusCode: http.StatusUnauthorized, + }, nil + } + + accessToken := types.CreateToken(user) + successMsg := fmt.Sprintf(`{"access_token": "%s"}`, accessToken) + + return events.APIGatewayProxyResponse{ + Body: successMsg, + StatusCode: http.StatusOK, + }, nil +} diff --git a/cdkExample/lambda/app/app.go b/cdkExample/lambda/app/app.go new file mode 100644 index 0000000..7367c5a --- /dev/null +++ b/cdkExample/lambda/app/app.go @@ -0,0 +1,19 @@ +package app + +import ( + "lambda-func/api" + "lambda-func/database" +) + +type App struct { + ApiHandler api.ApiHandler +} + +func NewApp() App { + db := database.NewDynamoDB() + apiHandler := api.NewApiHandler(db) + + return App{ + ApiHandler: apiHandler, + } +} diff --git a/cdkExample/lambda/database/database.go b/cdkExample/lambda/database/database.go new file mode 100644 index 0000000..ef8de77 --- /dev/null +++ b/cdkExample/lambda/database/database.go @@ -0,0 +1,114 @@ +package database + +// This is going to be the logic that directly communicates with +// our database + +import ( + "fmt" + "lambda-func/types" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/dynamodb" + "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute" +) + +const ( + TABLE_NAME = "userTable2" +) + +type UserStore interface { + DoesUserExist(username string) (bool, error) + InsertUser(user types.User) error + GetUser(username string) (types.User, error) +} + +type DynamoDBClient struct { + databaseStore *dynamodb.DynamoDB +} + +func NewDynamoDB() DynamoDBClient { + dbSession := session.Must(session.NewSession()) + db := dynamodb.New(dbSession) + + return DynamoDBClient{ + databaseStore: db, + } +} + +// When we want to "register" a new user, we actually are: +// - checking if a user with this username already exists in our DB +// - if they do, we return an error +// - if they DONT, that is when we INSERT the user into the DB + +func (u DynamoDBClient) DoesUserExist(username string) (bool, error) { + result, err := u.databaseStore.GetItem(&dynamodb.GetItemInput{ + TableName: aws.String(TABLE_NAME), + Key: map[string]*dynamodb.AttributeValue{ + "username": { + S: aws.String(username), + }, + }, + }) + + if err != nil { + return true, err + } + + if result.Item == nil { + return false, nil + } + + return true, nil +} + +func (u DynamoDBClient) InsertUser(user types.User) error { + // we are assembling our item + item := &dynamodb.PutItemInput{ + TableName: aws.String(TABLE_NAME), + Item: map[string]*dynamodb.AttributeValue{ + "username": { + S: aws.String(user.Username), + }, + "password": { + S: aws.String(user.PasswordHash), + }, + }, + } + + // we want to actually insert the item + _, err := u.databaseStore.PutItem(item) + if err != nil { + return err + } + + return nil +} + +func (u DynamoDBClient) GetUser(username string) (types.User, error) { + var user types.User + + result, err := u.databaseStore.GetItem(&dynamodb.GetItemInput{ + TableName: aws.String(TABLE_NAME), + Key: map[string]*dynamodb.AttributeValue{ + "username": { + S: aws.String(username), + }, + }, + }) + + if err != nil { + return user, err + } + + if result.Item == nil { + return user, fmt.Errorf("user not found") + } + + err = dynamodbattribute.UnmarshalMap(result.Item, &user) + if err != nil { + return user, err + } + + return user, nil +} diff --git a/cdkExample/lambda/go.mod b/cdkExample/lambda/go.mod new file mode 100644 index 0000000..7a31d3e --- /dev/null +++ b/cdkExample/lambda/go.mod @@ -0,0 +1,8 @@ +module lambda-func + +go 1.21.3 + +require ( + github.com/golang-jwt/jwt/v5 v5.2.0 // indirect + golang.org/x/crypto v0.19.0 // indirect +) diff --git a/cdkExample/lambda/go.sum b/cdkExample/lambda/go.sum new file mode 100644 index 0000000..2d5129e --- /dev/null +++ b/cdkExample/lambda/go.sum @@ -0,0 +1,4 @@ +github.com/golang-jwt/jwt/v5 v5.2.0 h1:d/ix8ftRUorsN+5eMIlF4T6J8CAt9rch3My2winC1Jw= +github.com/golang-jwt/jwt/v5 v5.2.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= diff --git a/cdkExample/lambda/main b/cdkExample/lambda/main new file mode 100755 index 0000000..f117dec Binary files /dev/null and b/cdkExample/lambda/main differ diff --git a/cdkExample/lambda/main.go b/cdkExample/lambda/main.go new file mode 100644 index 0000000..00f5628 --- /dev/null +++ b/cdkExample/lambda/main.go @@ -0,0 +1,51 @@ +package main + +import ( + "fmt" + "lambda-func/app" + "lambda-func/middleware" + "net/http" + + "github.com/aws/aws-lambda-go/events" + "github.com/aws/aws-lambda-go/lambda" +) + +type MyEvent struct { + Username string `json:"username"` +} + +// Define our Handler +func HandleRequest(event MyEvent) (string, error) { + if event.Username == "" { + return "Invalid Request", fmt.Errorf("username cannot be empty") + } + + return fmt.Sprintf("Successfully called by - %s", event.Username), nil +} + +func ProtectedHandler(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + return events.APIGatewayProxyResponse{ + Body: "This is a protected route", + StatusCode: http.StatusOK, + }, nil +} + +func main() { + lambdaApp := app.NewApp() + lambda.Start(func(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + switch request.Path { + case "/register": + return lambdaApp.ApiHandler.RegisterUser(request) + case "/login": + return lambdaApp.ApiHandler.LoginUser(request) + case "/protected": + return middleware.ValidateJWTMiddleware(ProtectedHandler)(request) + default: + return events.APIGatewayProxyResponse{ + Body: "Not found", + StatusCode: http.StatusNotFound, + }, nil + } + + }) +} diff --git a/cdkExample/lambda/middleware/middleware.go b/cdkExample/lambda/middleware/middleware.go new file mode 100644 index 0000000..b9132be --- /dev/null +++ b/cdkExample/lambda/middleware/middleware.go @@ -0,0 +1,83 @@ +package middleware + +import ( + "fmt" + "net/http" + "strings" + "time" + + "github.com/aws/aws-lambda-go/events" + "github.com/golang-jwt/jwt/v5" +) + +func ValidateJWTMiddleware(next func(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error)) func(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + return func(request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) { + // extract the headers from our token + tokenString := extractTokenFromHeaders(request.Headers) + if tokenString == "" { + return events.APIGatewayProxyResponse{ + Body: "Missing Auth token", + StatusCode: http.StatusUnauthorized, + }, nil + } + // parse the token for our claims + + claims, err := parseToken(tokenString) + if err != nil { + return events.APIGatewayProxyResponse{ + Body: "User Unauthorized", + StatusCode: http.StatusUnauthorized, + }, err + } + + // did this token expire + expires := int64(claims["expires"].(float64)) + if time.Now().Unix() > expires { + return events.APIGatewayProxyResponse{ + Body: "token expired", + StatusCode: http.StatusUnauthorized, + }, nil + } + + return next(request) + } + +} + +func extractTokenFromHeaders(headers map[string]string) string { + authHeader, ok := headers["Authorization"] + + if !ok { + return "" + } + + splitToken := strings.Split(authHeader, "Bearer ") + if len(splitToken) != 2 { + return "" + } + + return splitToken[1] +} + +func parseToken(tokenString string) (jwt.MapClaims, error) { + token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) { + secret := "mySecret" + return []byte(secret), nil + }) + + if err != nil { + return nil, fmt.Errorf("unauthorized") + } + + if !token.Valid { + return nil, fmt.Errorf("token is not valid - unauthorized") + } + + claims, ok := token.Claims.(jwt.MapClaims) + if !ok { + return nil, fmt.Errorf("token of unrecognized type - unauthorized") + } + + return claims, nil + +} diff --git a/cdkExample/lambda/types/types.go b/cdkExample/lambda/types/types.go new file mode 100644 index 0000000..da60d75 --- /dev/null +++ b/cdkExample/lambda/types/types.go @@ -0,0 +1,60 @@ +package types + +import ( + "fmt" + "time" + + "github.com/golang-jwt/jwt/v5" + "golang.org/x/crypto/bcrypt" +) + +// Where we can define types and other misc. functions + +type RegisterUser struct { + Username string `json:"username"` + Password string `json:"password"` +} + +type User struct { + Username string `json:"username"` + PasswordHash string `json:"password"` +} + +func NewUser(registerUser RegisterUser) (User, error) { + hashedPassword, err := bcrypt.GenerateFromPassword([]byte(registerUser.Password), 10) + if err != nil { + return User{}, err + } + + return User{ + Username: registerUser.Username, + PasswordHash: string(hashedPassword), + }, nil +} + +func ValidatePassword(hashedPassword, plainTextPassword string) bool { + err := bcrypt.CompareHashAndPassword([]byte(hashedPassword), []byte(plainTextPassword)) + return err == nil +} + +func CreateToken(user User) string { + now := time.Now() + validUntil := now.Add(time.Hour * 1).Unix() + + claims := jwt.MapClaims{ + "user": user.Username, + "expires": validUntil, + } + + token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims, nil) + + secret := "mySecret" + + tokenString, err := token.SignedString([]byte(secret)) + if err != nil { + fmt.Errorf("signingString error %w", err) + return tokenString + } + + return tokenString +}