CodeBuild pacchetto di modelli di provisioning - AWS Proton
Esempio: AWS CDK

Avviso di fine del supporto: il 7 ottobre 2026, AWS terminerà il supporto per AWS Proton. Dopo il 7 ottobre 2026, non potrai più accedere alla AWS Proton console o AWS Proton alle risorse. L'infrastruttura implementata rimarrà intatta. Per ulteriori informazioni, consulta AWS Proton Service Deprecation and Migration Guide.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

CodeBuild pacchetto di modelli di provisioning

Con il CodeBuild provisioning, invece di utilizzare i modelli IAc per renderizzare i file IAc ed eseguirli utilizzando un motore di provisioning IaC, AWS Proton esegue semplicemente i comandi della shell. A tale scopo, AWS Proton crea un AWS CodeBuild progetto per l'ambiente, nell'account di ambiente, e avvia un processo per eseguire i comandi per ogni AWS Proton creazione o aggiornamento delle risorse. Quando si crea un pacchetto di modelli, si fornisce un manifesto che specifica i comandi di provisioning e deprovisioning dell'infrastruttura e tutti i programmi, gli script e gli altri file necessari a tali comandi. I comandi sono in grado di leggere gli input che AWS Proton forniscono e sono responsabili del provisioning o del deprovisioning dell'infrastruttura e della generazione di valori di output.

Il manifesto specifica inoltre come AWS Proton deve essere visualizzato il file di input da cui il codice può immettere e da cui ottenere i valori di input. Può essere renderizzato in JSON o HCL. Per ulteriori informazioni sui parametri di input, vedere. CodeBuild dettagli ed esempi dei parametri di provisioning Per ulteriori informazioni sui file manifest, consulta Raccogli i file modello per AWS Proton.

Nota

È possibile utilizzare il CodeBuild provisioning con ambienti e servizi. Al momento non è possibile effettuare il provisioning dei componenti in questo modo.

Esempio: utilizzo di AWS CDK with CodeBuild provisioning

Come esempio di utilizzo del CodeBuild provisioning, è possibile includere codice che utilizza le AWS risorse AWS Cloud Development Kit (AWS CDK) per fornire (distribuire) e deprovisionare (distruggere) e un manifest che installa il CDK ed esegue il codice CDK.

Nelle sezioni seguenti sono elencati i file di esempio che è possibile includere in un pacchetto di modelli di provisioning che effettua il CodeBuild provisioning di un ambiente utilizzando. AWS CDK

Il seguente file manifesto specifica il CodeBuild provisioning e include i comandi necessari per installare e utilizzare il file di output AWS CDK, l'elaborazione dei file di output e la restituzione degli output. AWS Proton

Esempio infrastruttura/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 }}"

Il seguente file di schema definisce i parametri per l'ambiente. Il AWS CDK codice può fare riferimento ai valori di questi parametri durante la distribuzione.

Esempio 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

I seguenti file sono un esempio di progetto CDK Node.js.

Esempio infrastruttura/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"
  }
}
Esempio infrastruttura/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"
  ]
}
Esempio infrastruttura/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"
    ]
  }
}
Esempio 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', {});
Esempio 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`
    });
  }
}

Quando si crea un ambiente utilizzando un modello di provisioning CodeBuild basato su un modello di provisioning, AWS Proton esegue il rendering di un file di input con i valori dei parametri di input forniti dall'utente. Il codice può fare riferimento a questi valori. Il file seguente è un esempio di file di input renderizzato.

Esempio infrastruttura/proton-inputs.json
{
  "environment": {
    "name": "myenv",
    "inputs": {
      "my_sample_input": "10.0.0.0/16",
      "my_other_sample_input": "11.0.0.0/16"
    }
  }
}