CodeBuild paquete de plantillas de aprovisionamiento

Con el CodeBuild aprovisionamiento, en lugar de utilizar plantillas de IaC para renderizar los archivos de IaC y ejecutarlos mediante un motor de aprovisionamiento de IaC, AWS Proton basta con ejecutar los comandos del shell. Para ello, AWS Proton crea un AWS CodeBuild proyecto para el entorno, en la cuenta de entorno, e inicia un trabajo para ejecutar los comandos correspondientes a cada AWS Proton creación o actualización de recursos. Al crear un paquete de plantillas, se proporciona un manifiesto en el que se especifican los comandos de aprovisionamiento y desaprovisionamiento de la infraestructura, así como los programas, scripts y otros archivos que puedan necesitar estos comandos. Los comandos pueden leer las entradas que proporciona AWS Proton , y son responsables de aprovisionar o desaprovisionar la infraestructura y generar valores de salida.

El manifiesto también especifica cómo se AWS Proton debe representar el archivo de entrada en el que el código puede introducir y del que puede obtener valores de entrada. Se puede renderizar en JSON o HCL. Para obtener más información sobre los parámetros de entrada, consulteCodeBuild detalles y ejemplos de los parámetros de aprovisionamiento. Para obtener más información sobre los archivos de manifiesto, consulte Resuma los archivos de plantilla para AWS Proton.

nota

Puede utilizar el CodeBuild aprovisionamiento con entornos y servicios. En este momento, no puede aprovisionar componentes de esta forma.

Ejemplo: usar el AWS CDK con aprovisionamiento CodeBuild

Como ejemplo del uso del CodeBuild aprovisionamiento, puedes incluir un código que lo utilice AWS Cloud Development Kit (AWS CDK) para aprovisionar (implementar) y desaprovisionar (destruir) AWS los recursos, y un manifiesto que instale la CDK y ejecute el código de la CDK.

En las siguientes secciones se enumeran ejemplos de archivos que puede incluir en un paquete de plantillas de CodeBuild aprovisionamiento que aprovisione un entorno mediante. AWS CDK

Manifiesto

El siguiente archivo de manifiesto especifica el CodeBuild aprovisionamiento e incluye los comandos necesarios para instalarlo y usarlo AWS CDK, procesar el archivo de salida y generar informes sobre los resultados. AWS Proton

ejemplo 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

El siguiente archivo de esquema define los parámetros del entorno. AWS CDK El código puede hacer referencia a los valores de estos parámetros durante la implementación.

ejemplo 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 archivos

Los siguientes archivos son un ejemplo de un proyecto de CDK de Node.js.

ejemplo infraestructura/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"
  }
}

ejemplo infraestructura/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"
  ]
}

ejemplo infraestructura/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"
    ]
  }
}

ejemplo infraestructura/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', {});

ejemplo infraestructura/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`
    });
  }
}

Archivo de entrada renderizado

Cuando crea un entorno mediante una plantilla de aprovisionamiento CodeBuild basada en ella, representa un archivo de entrada con AWS Proton los valores de los parámetros de entrada que haya proporcionado. El código puede hacer referencia a estos valores. El siguiente archivo es un ejemplo de un archivo de entrada renderizado.

ejemplo 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"
    }
  }
}