CodeBuild Vorlagenpaket für die Bereitstellung - AWS Proton
Beispiel: AWS CDK

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

CodeBuild Vorlagenpaket für die Bereitstellung

Anstatt IaC-Vorlagen zum Rendern von IaC-Dateien zu verwenden und sie mit einer CodeBuild IaC-Provisioning-Engine auszuführen, AWS Proton werden beim Provisioning einfach Ihre Shell-Befehle ausgeführt. Erstellen Sie dazu ein AWS CodeBuild Projekt für die Umgebung im Umgebungskonto und starten Sie einen Job, um Ihre Befehle für jede AWS Proton Ressourcenerstellung oder Aktualisierung auszuführen. AWS Proton Wenn Sie ein Vorlagenpaket erstellen, stellen Sie ein Manifest bereit, das die Befehle zur Bereitstellung und Deprovisionierung der Infrastruktur sowie alle Programme, Skripts und anderen Dateien angibt, die für diese Befehle möglicherweise erforderlich sind. Ihre Befehle können Eingaben lesen, die die Infrastruktur bereitstellen, und sind für die AWS Proton Bereitstellung oder Deprovisionierung der Infrastruktur und die Generierung von Ausgabewerten verantwortlich.

Das Manifest legt auch fest, wie die Eingabedatei gerendert AWS Proton werden soll, aus der Ihr Code Eingabewerte eingeben und aus der Sie Eingabewerte abrufen können. Es kann in JSON oder HCL gerendert werden. Weitere Hinweise zu Eingabeparametern finden Sie unterCodeBuild Details und Beispiele für Bereitstellungsparameter. Weitere Informationen zu Manifestdateien finden Sie unter Verpacken Sie die Vorlagendateien für AWS Proton.

Anmerkung

Sie können die CodeBuild Bereitstellung mit Umgebungen und Diensten verwenden. Derzeit können Sie Komponenten auf diese Weise nicht bereitstellen.

Beispiel: Verwendung von AWS CDK with CodeBuild Provisioning

Als Beispiel für die Verwendung von CodeBuild Provisioning können Sie Code hinzufügen, der AWS Cloud Development Kit (AWS CDK) AWS Ressourcen bereitstellt (bereitstellt) und deprovisioniert (zerstört), sowie ein Manifest, das das CDK installiert und Ihren CDK-Code ausführt.

In den folgenden Abschnitten sind Beispieldateien aufgeführt, die Sie in ein CodeBuild Provisioning-Vorlagenpaket aufnehmen können, das eine Umgebung mithilfe von bereitstellt. AWS CDK

Die folgende Manifestdatei spezifiziert die CodeBuild Bereitstellung und enthält die Befehle, die für die Installation und Verwendung der Datei AWS CDK, die Verarbeitung der Ausgabedatei und die Rückmeldung der Ausgaben an erforderlich sind. AWS Proton

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

Die folgende Schemadatei definiert Parameter für die Umgebung. Ihr AWS CDK Code kann während der Bereitstellung auf Werte dieser Parameter verweisen.

Beispiel 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

Die folgenden Dateien sind ein Beispiel für ein Node.js CDK-Projekt.

Beispiel 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"
  }
}
Beispiel infrastruktur/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"
  ]
}
Beispiel infrastruktur/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"
    ]
  }
}
Beispiel infrastructure/bin/ProtonEnvironment.ts
#!/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', {});
Beispiel infrastructure/lib/ProtonEnvironmentStack.ts
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`
    });
  }
}

Wenn Sie eine Umgebung mithilfe einer CodeBuild basierten Bereitstellungsvorlage erstellen, wird eine Eingabedatei mit den von Ihnen angegebenen Eingabeparameterwerten AWS Proton gerendert. Ihr Code kann sich auf diese Werte beziehen. Die folgende Datei ist ein Beispiel für eine gerenderte Eingabedatei.

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