Comprehensive comparison for DevOps technology in Software Development applications

AWSTemplateFormatVersion: '2010-09-09'
Description: 'Production-ready CloudFormation template for a flexible REST API with Lambda, API Gateway, and DynamoDB'

Parameters:
  Environment:
    Type: String
    Default: production
    AllowedValues:
      - development
      - staging
      - production
    Description: Environment name for resource tagging and configuration
  
  ApiStageName:
    Type: String
    Default: v1
    Description: API Gateway stage name

Resources:
  # DynamoDB Table for User Data
  UsersTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: !Sub '${Environment}-users-table'
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: userId
          AttributeType: S
        - AttributeName: email
          AttributeType: S
      KeySchema:
        - AttributeName: userId
          KeyType: HASH
      GlobalSecondaryIndexes:
        - IndexName: EmailIndex
          KeySchema:
            - AttributeName: email
              KeyType: HASH
          Projection:
            ProjectionType: ALL
      PointInTimeRecoverySpecification:
        PointInTimeRecoveryEnabled: true
      SSESpecification:
        SSEEnabled: true
      Tags:
        - Key: Environment
          Value: !Ref Environment

  # Lambda Execution Role
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
      Policies:
        - PolicyName: DynamoDBAccess
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - 'dynamodb:GetItem'
                  - 'dynamodb:PutItem'
                  - 'dynamodb:UpdateItem'
                  - 'dynamodb:Query'
                  - 'dynamodb:Scan'
                Resource:
                  - !GetAtt UsersTable.Arn
                  - !Sub '${UsersTable.Arn}/index/*'

  # Lambda Function for User API
  UserApiFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: !Sub '${Environment}-user-api'
      Runtime: python3.11
      Handler: index.lambda_handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Timeout: 30
      MemorySize: 512
      Environment:
        Variables:
          USERS_TABLE: !Ref UsersTable
          ENVIRONMENT: !Ref Environment
      Code:
        ZipFile: |
          import json
          import os
          import boto3
          from datetime import datetime
          import uuid
          
          dynamodb = boto3.resource('dynamodb')
          table = dynamodb.Table(os.environ['USERS_TABLE'])
          
          def lambda_handler(event, context):
              try:
                  http_method = event['httpMethod']
                  path = event['path']
                  
                  if http_method == 'POST' and path == '/users':
                      return create_user(event)
                  elif http_method == 'GET' and path.startswith('/users/'):
                      return get_user(event)
                  else:
                      return response(404, {'error': 'Not found'})
              except Exception as e:
                  return response(500, {'error': str(e)})
          
          def create_user(event):
              body = json.loads(event['body'])
              user_id = str(uuid.uuid4())
              
              item = {
                  'userId': user_id,
                  'email': body['email'],
                  'name': body.get('name', ''),
                  'createdAt': datetime.utcnow().isoformat()
              }
              
              table.put_item(Item=item)
              return response(201, item)
          
          def get_user(event):
              user_id = event['pathParameters']['userId']
              result = table.get_item(Key={'userId': user_id})
              
              if 'Item' not in result:
                  return response(404, {'error': 'User not found'})
              
              return response(200, result['Item'])
          
          def response(status_code, body):
              return {
                  'statusCode': status_code,
                  'headers': {
                      'Content-Type': 'application/json',
                      'Access-Control-Allow-Origin': '*'
                  },
                  'body': json.dumps(body)
              }

  # API Gateway REST API
  UserApi:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: !Sub '${Environment}-user-api'
      Description: User management REST API
      EndpointConfiguration:
        Types:
          - REGIONAL

  # API Gateway Resource
  UsersResource:
    Type: AWS::ApiGateway::Resource
    Properties:
      RestApiId: !Ref UserApi
      ParentId: !GetAtt UserApi.RootResourceId
      PathPart: users

  UserResource:
    Type: AWS::ApiGateway::Resource
    Properties:
      RestApiId: !Ref UserApi
      ParentId: !Ref UsersResource
      PathPart: '{userId}'

  # POST Method
  PostMethod:
    Type: AWS::ApiGateway::Method
    Properties:
      RestApiId: !Ref UserApi
      ResourceId: !Ref UsersResource
      HttpMethod: POST
      AuthorizationType: NONE
      Integration:
        Type: AWS_PROXY
        IntegrationHttpMethod: POST
        Uri: !Sub 'arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${UserApiFunction.Arn}/invocations'

  # GET Method
  GetMethod:
    Type: AWS::ApiGateway::Method
    Properties:
      RestApiId: !Ref UserApi
      ResourceId: !Ref UserResource
      HttpMethod: GET
      AuthorizationType: NONE
      Integration:
        Type: AWS_PROXY
        IntegrationHttpMethod: POST
        Uri: !Sub 'arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${UserApiFunction.Arn}/invocations'

  # API Gateway Deployment
  ApiDeployment:
    Type: AWS::ApiGateway::Deployment
    DependsOn:
      - PostMethod
      - GetMethod
    Properties:
      RestApiId: !Ref UserApi
      StageName: !Ref ApiStageName

  # Lambda Permission for API Gateway
  LambdaApiPermission:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref UserApiFunction
      Action: 'lambda:InvokeFunction'
      Principal: apigateway.amazonaws.com
      SourceArn: !Sub 'arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${UserApi}/*/*'

Outputs:
  ApiEndpoint:
    Description: API Gateway endpoint URL
    Value: !Sub 'https://${UserApi}.execute-api.${AWS::Region}.amazonaws.com/${ApiStageName}'
    Export:
      Name: !Sub '${Environment}-user-api-endpoint'
  
  UsersTableName:
    Description: DynamoDB Users Table Name
    Value: !Ref UsersTable
    Export:
      Name: !Sub '${Environment}-users-table-name'
  
  LambdaFunctionArn:
    Description: Lambda Function ARN
    Value: !GetAtt UserApiFunction.Arn
    Export:
      Name: !Sub '${Environment}-user-api-function-arn'