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](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html) 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](parameters-codebuild.md) Per ulteriori informazioni sui file manifest, consulta [Raccogli i file modello per AWS Proton](ag-wrap-up.md).
**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
### Manifesto
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
**Example 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 }}"
```
### Schema
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.
**Example 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 file
I seguenti file sono un esempio di progetto CDK Node.js.
**Example 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"
}
}
```
**Example 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"
]
}
```
**Example 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"
]
}
}
```
**Example 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', {});
```
**Example 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`
});
}
}
```
### File di input renderizzato
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](https://docs.aws.amazon.com/proton/latest/userguide/parameters.html) forniti dall'utente. Il codice può fare riferimento a questi valori. Il file seguente è un esempio di file di input renderizzato.
**Example 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"
}
}
}
```