CodeBuild pacote de modelos de provisionamento

Com o CodeBuild provisionamento, em vez de usar modelos de IaC para renderizar arquivos de IaC e executá-los usando um mecanismo de provisionamento de IaC, basta executar seus comandos de shell. AWS Proton Para fazer isso, AWS Proton cria um AWS CodeBuild projeto para o ambiente, na conta do ambiente, e inicia um trabalho para executar seus comandos para cada criação ou atualização de AWS Proton recursos. Ao criar um pacote de modelos, você fornece um manifesto que especifica os comandos de provisionamento e desprovisionamento da infraestrutura e quaisquer programas, scripts e outros arquivos que esses comandos possam precisar. Seus comandos podem ler as entradas que o AWS Proton fornece e são responsáveis por provisionar ou desprovisionar a infraestrutura e gerar valores de saída.

O manifesto também especifica como AWS Proton renderizar o arquivo de entrada que seu código pode inserir e do qual obter valores de entrada. Ele pode ser renderizado em JSON ou HCL. Para obter mais informações sobre os parâmetros de entrada, consulte CodeBuild detalhes e exemplos de parâmetros de provisionamento. Para obter mais informações sobre arquivos manifesto, consulte Encapsular arquivos de modelo para AWS Proton.

nota

Você pode usar o CodeBuild provisionamento com ambientes e serviços. No momento, você não pode provisionar componentes dessa forma.

Exemplo: usando o AWS CDK com CodeBuild provisionamento

Como exemplo do uso do CodeBuild provisionamento, você pode incluir um código que usa os AWS recursos AWS Cloud Development Kit (AWS CDK) para provisionar (implantar) e desprovisionar (destruir) e um manifesto que instala o CDK e executa seu código CDK.

As seções a seguir listam exemplos de arquivos que você pode incluir em um pacote de modelos CodeBuild de provisionamento que provisiona um ambiente usando o. AWS CDK

Manifesto

O arquivo de manifesto a seguir especifica o CodeBuild provisionamento e inclui os comandos necessários para instalar e usar o arquivo de saída AWS CDK, processar o arquivo e reportar as saídas para. AWS Proton

exemplo infrastructure/manifest.yaml

infrastructure:
  templates:
    - rendering_engine: codebuild
      settings:
        image: aws/codebuild/amazonlinux2-x86_64-standard:4.0
        runtimes:
          nodejs: 16
        provision:
          - npm install
          - npm run build
          - npm run cdk bootstrap
          - npm run cdk deploy -- --require-approval never --outputs-file proton-outputs.json
          - jq 'to_entries | map_values(.value) | add | to_entries | map({key:.key, valueString:.value})' < proton-outputs.json > outputs.json
          - aws proton notify-resource-deployment-status-change --resource-arn $RESOURCE_ARN --status IN_PROGRESS --outputs file://./outputs.json
        deprovision:
          - npm install
          - npm run build
          - npm run cdk destroy
        project_properties:
          VpcConfig:
            VpcId: "{{ environment.inputs.codebuild_vpc_id }}"
            Subnets: "{{ environment.inputs.codebuild_subnets }}"
            SecurityGroupIds: "{{ environment.inputs.codebuild_security_groups }}"

Esquema

O arquivo de esquema a seguir define parâmetros para o ambiente. Seu AWS CDK código pode se referir aos valores desses parâmetros durante a implantação.

exemplo schema/schema.yaml

schema:
  format:
    openapi: "3.0.0"
  environment_input_type: "MyEnvironmentInputType"
  types:
    MyEnvironmentInputType:
      type: object
      description: "Input properties for my environment"
      properties:
        my_sample_input:
          type: string
          description: "This is a sample input"
          default: "hello world"
        my_other_sample_input:
          type: string
          description: "Another sample input"
      required:
        - my_other_sample_input

AWS CDK arquivos

Os arquivos a seguir são um exemplo de um projeto CDK do Node.js.

exemplo infrastructure/package.json

{
  "name": "ProtonEnvironment",
  "version": "0.1.0",
  "bin": {
    "ProtonEnvironmente": "bin/ProtonEnvironment.js"
  },
  "scripts": {
    "build": "tsc",
    "watch": "tsc -w",
    "test": "jest",
    "cdk": "cdk"
  },
  "devDependencies": {
    "@types/jest": "^28.1.7",
    "@types/node": "18.7.6",
    "jest": "^28.1.3",
    "ts-jest": "^28.0.8",
    "aws-cdk": "2.37.1",
    "ts-node": "^10.9.1",
    "typescript": "~4.7.4"
  },
  "dependencies": {
    "aws-cdk-lib": "2.37.1",
    "constructs": "^10.1.77",
    "source-map-support": "^0.5.21"
  }
}

exemplo infrastructure/tsconfig.json

{
  "compilerOptions": {
    "target": "ES2018",
    "module": "commonjs",
    "lib": [
      "es2018"
    ],
    "declaration": true,
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "noImplicitThis": true,
    "alwaysStrict": true,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": false,
    "inlineSourceMap": true,
    "inlineSources": true,
    "experimentalDecorators": true,
    "strictPropertyInitialization": false,
    "resolveJsonModule": true,
    "esModuleInterop": true,
    "typeRoots": [
      "./node_modules/@types"
    ]
  },
  "exclude": [
    "node_modules",
    "cdk.out"
  ]
}

exemplo infrastructure/cdk.json

{
  "app": "npx ts-node --prefer-ts-exts bin/ProtonEnvironment.ts",
  "outputsFile": "proton-outputs.json",
  "watch": {
    "include": [
      "**"
    ],
    "exclude": [
      "README.md",
      "cdk*.json",
      "**/*.d.ts",
      "**/*.js",
      "tsconfig.json",
      "package*.json",
      "yarn.lock",
      "node_modules",
      "test"
    ]
  },
  "context": {
    "@aws-cdk/aws-apigateway:usagePlanKeyOrderInsensitiveId": true,
    "@aws-cdk/core:stackRelativeExports": true,
    "@aws-cdk/aws-rds:lowercaseDbIdentifier": true,
    "@aws-cdk/aws-lambda:recognizeVersionProps": true,
    "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021": true,
    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
    "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true,
    "@aws-cdk/core:target-partitions": [
      "aws",
      "aws-cn"
    ]
  }
}

exemplo infraestrutura/bin/.ts ProtonEnvironment

#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { ProtonEnvironmentStack } from '../lib/ProtonEnvironmentStack';

const app = new cdk.App();
new ProtonEnvironmentStack(app, 'ProtonEnvironmentStack', {});

exemplo infraestrutura/lib/.ts ProtonEnvironmentStack

import { Stack, StackProps } from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as cdk from 'aws-cdk-lib';
import * as ssm from 'aws-cdk-lib/aws-ssm';
import input from '../proton-inputs.json';

export class ProtonEnvironmentStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, { ...props, stackName: process.env.STACK_NAME });

    const ssmParam = new ssm.StringParameter(this, "ssmParam", {
      stringValue: input.environment.inputs.my_sample_input,
      parameterName: `${process.env.STACK_NAME}-Param`,
      tier: ssm.ParameterTier.STANDARD
    })

    new cdk.CfnOutput(this, 'ssmParamOutput', {
      value: ssmParam.parameterName,
      description: 'The name of the ssm parameter',
      exportName: `${process.env.STACK_NAME}-Param`
    });
  }
}

Arquivo de entrada renderizado

Quando você cria um ambiente usando um modelo de provisionamento CodeBuild baseado, AWS Proton renderiza um arquivo de entrada com os valores dos parâmetros de entrada fornecidos por você. Seu código pode se referir a esses valores. O arquivo a seguir é um exemplo de um arquivo de entrada renderizado.

exemplo infrastructure/proton-inputs.json

{
  "environment": {
    "name": "myenv",
    "inputs": {
      "my_sample_input": "10.0.0.0/16",
      "my_other_sample_input": "11.0.0.0/16"
    }
  }
}