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à.
# File di schema
In qualità di amministratore, quando utilizzi la [sezione Open API Data Models (schemas) per definire un file YAML dello schema di parametri per il tuo pacchetto di modelli](https://swagger.io/docs/specification/data-models/), AWS Proton puoi convalidare gli input dei valori dei parametri in base ai requisiti definiti nello schema.
Per ulteriori informazioni sui formati e sulle parole chiave disponibili, consulta la sezione [Oggetto Schema](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.3.md#schemaObject) di OpenAPI.
## Requisiti dello schema per i pacchetti di modelli di ambiente
Lo schema deve seguire la [sezione Data Models (schemas)](https://swagger.io/docs/specification/data-models/) di OpenAPI in formato YAML. Deve inoltre far parte del pacchetto di modelli di ambiente.
Per lo schema dell'ambiente, devi includere le intestazioni formattate per stabilire che stai utilizzando la sezione Data Models (schemas) dell'Open API. Nei seguenti esempi di schemi di ambiente, queste intestazioni vengono visualizzate nelle prime tre righe.
Un `environment_input_type` deve essere incluso e definito con un nome fornito dall'utente. Negli esempi seguenti, questo è definito alla riga 5. Definendo questo parametro, lo si associa a una risorsa AWS Proton ambientale.
Per seguire il modello di schema Open API, è necessario includere`types`. Nell'esempio seguente, questa è la riga 6.
Di seguito`types`, è necessario definire un `environment_input_type` tipo. I parametri di input per l'ambiente vengono definiti come proprietà di`environment_input_type`. È necessario includere almeno una proprietà con un nome che corrisponda ad almeno un parametro elencato nell'infrastruttura di ambiente come file di codice (IaC) associato allo schema.
Quando create un ambiente e fornite valori di parametro personalizzati, AWS Proton utilizza il file di schema per abbinarli, convalidarli e inserirli nei parametri tra parentesi graffe del file IAc associato. CloudFormation Per ogni proprietà (parametro), fornite una e. `name` `type` Facoltativamente, fornisci anche un `description``default`, e`pattern`.
I parametri definiti per lo schema del modello di ambiente *standard* di esempio seguente includono `vpc_cidr``subnet_one_cidr`, e `subnet_two_cidr` con la `default` parola chiave e i valori predefiniti. Quando si crea un ambiente con questo schema di bundle di modelli di ambiente, è possibile accettare i valori predefiniti o fornire valori personalizzati. Se un parametro *non ha* un valore predefinito ed è elencato come `required` proprietà (parametro), è necessario fornire i relativi valori quando si crea un ambiente.
Il secondo esempio di schema di modello di ambiente *standard* elenca il `required` parametro`my_other_sample_input`.
È possibile creare uno schema per due tipi di modelli di ambiente. Per ulteriori informazioni, consulta [Registra e pubblica modelli](template-create.md).
+ **Modelli di ambiente *standard***
Nell'esempio seguente, viene definito un tipo di input di ambiente con una descrizione e proprietà di input. Questo esempio di schema può essere utilizzato con il file AWS Proton CloudFormation IAc mostrato nell'[Esempio 3](ag-infrastructure-tmp-files-cloudformation.md#ag-proton-env-cfn-example).
Schema di esempio per un modello di ambiente *standard*:
```
schema: # required
format: # required
openapi: "3.0.0" # required
# required defined by administrator
environment_input_type: "PublicEnvironmentInput"
types: # required
# defined by administrator
PublicEnvironmentInput:
type: object
description: "Input properties for my environment"
properties:
vpc_cidr: # parameter
type: string
description: "This CIDR range for your VPC"
default: 10.0.0.0/16
pattern: ([0-9]{1,3}\.){3}[0-9]{1,3}($|/(16|24))
subnet_one_cidr: # parameter
type: string
description: "The CIDR range for subnet one"
default: 10.0.0.0/24
pattern: ([0-9]{1,3}\.){3}[0-9]{1,3}($|/(16|24))
subnet_two_cidr: # parameter
type: string
description: "The CIDR range for subnet one"
default: 10.0.1.0/24
pattern: ([0-9]{1,3}\.){3}[0-9]{1,3}($|/(16|24))
```
Schema di esempio per un modello di ambiente *standard* che include un `required` parametro:
```
schema: # required
format: # required
openapi: "3.0.0" # required
# required defined by administrator
environment_input_type: "MyEnvironmentInputType"
types: # required
# defined by administrator
MyEnvironmentInputType:
type: object
description: "Input properties for my environment"
properties:
my_sample_input: # parameter
type: string
description: "This is a sample input"
default: "hello world"
my_other_sample_input: # parameter
type: string
description: "Another sample input"
another_optional_input: # parameter
type: string
description: "Another optional input"
default: "!"
required:
- my_other_sample_input
```
+ **Modelli di ambiente *gestiti dal cliente***
*Nell'esempio seguente, lo schema include solo un elenco di output che replicano gli output dell'IaC utilizzato per il provisioning dell'infrastruttura gestita dal cliente.* È necessario definire i tipi di valori di output *solo come stringhe* (*non* elenchi, array o altri tipi). Ad esempio, il frammento di codice successivo mostra la sezione degli output di un modello esterno. CloudFormation [Questo è tratto dal modello mostrato nell'Esempio 1.](ag-infrastructure-tmp-files-cloudformation.md#ag-env-cfn-example) Può essere utilizzato per creare un'infrastruttura esterna *gestita dai clienti* per un servizio AWS Proton Fargate creato dall'[Esempio](ag-infrastructure-tmp-files-cloudformation.md#ag-proton-svc-cfn-example) 4.
**Importante**
In qualità di amministratore, è necessario assicurarsi che l'infrastruttura fornita e gestita e tutti i parametri di output siano compatibili con i modelli di ambiente *gestito dal cliente* associati. AWS Proton non puoi tenere conto delle modifiche per tuo conto perché queste modifiche non sono visibili a AWS Proton. Le incoerenze provocano errori.
*Esempi di output di file CloudFormation IaC per un modello di ambiente gestito dal cliente:*
```
// Cloudformation Template Outputs
[...]
Outputs:
ClusterName:
Description: The name of the ECS cluster
Value: !Ref 'ECSCluster'
ECSTaskExecutionRole:
Description: The ARN of the ECS role
Value: !GetAtt 'ECSTaskExecutionRole.Arn'
VpcId:
Description: The ID of the VPC that this stack is deployed in
Value: !Ref 'VPC'
[...]
```
Lo schema per il corrispondente pacchetto di modelli di ambiente *gestito dal AWS Proton cliente* è illustrato nell'esempio seguente. Ogni valore di output è definito come una stringa.
Schema di esempio per un modello di ambiente *gestito dal cliente*:
```
schema: # required
format: # required
openapi: "3.0.0" # required
# required defined by administrator
environment_input_type: "EnvironmentOutput"
types: # required
# defined by administrator
EnvironmentOutput:
type: object
description: "Outputs of the environment"
properties:
ClusterName: # parameter
type: string
description: "The name of the ECS cluster"
ECSTaskExecutionRole: # parameter
type: string
description: "The ARN of the ECS role"
VpcId: # parameter
type: string
description: "The ID of the VPC that this stack is deployed in"
[...]
```
## Requisiti dello schema per i pacchetti di modelli di servizio
Lo schema deve seguire la [sezione Data Models (schemas)](https://swagger.io/docs/specification/data-models/) di OpenAPI in formato YAML, come mostrato negli esempi seguenti. È necessario fornire un file di schema nel pacchetto di modelli di servizio.
Nei seguenti esempi di schemi di servizio, è necessario includere le intestazioni formattate. Nell'esempio seguente, si tratta delle prime tre righe. Questo serve a stabilire che stai utilizzando la sezione Data Models (schemas) dell'Open API.
A `service_input_type` deve essere incluso e definito con un nome fornito dall'utente. Nell'esempio seguente, si trova nella riga 5. Ciò associa i parametri a una risorsa AWS Proton di servizio.
Una pipeline di AWS Proton servizi è inclusa per impostazione predefinita quando si utilizza la console o la CLI per creare un servizio. Quando includi una pipeline di servizi per il tuo servizio, devi includerla `pipeline_input_type` con un nome fornito. Nell'esempio seguente, si tratta della riga 7. *Non* includere questo parametro se *non* includi una pipeline AWS Proton di servizi. Per ulteriori informazioni, consulta [Registra e pubblica modelli](template-create.md).
Per seguire il modello di schema Open API, è necessario includere `types` Nel seguente esempio, questo è nella riga 9.
Di seguito`types`, è necessario definire un `service_input_type` tipo. I parametri di input per il servizio vengono definiti come proprietà di`service_input_type`. È necessario includere almeno una proprietà con un nome che corrisponda ad almeno un parametro elencato nel file Service Infrastructure as Code (IaC) associato allo schema.
Per definire una pipeline di servizi, al di sotto della vostra `service_input_type` definizione, è necessario definire un. `pipeline_input_type` Come sopra, è necessario includere almeno una proprietà con un nome che corrisponda ad almeno un parametro elencato in un file IAc di pipeline associato allo schema. *Non* includete questa definizione se *non* includete una pipeline di AWS Proton servizi.
Quando, in qualità di amministratore o sviluppatore, create un servizio e fornite valori di parametri personalizzati, AWS Proton utilizzate il file di schema per abbinarli, convalidarli e inserirli nei parametri rinforzati ricci del file CloudFormation IAc associato. Per ogni proprietà (parametro), fornisci a e a. `name` `type` Facoltativamente, fornisci anche un `description``default`, e`pattern`.
I parametri definiti per lo schema di esempio includono `port` `task_size` e `image` con la `default` parola chiave e i valori predefiniti. `desired_count` Quando si crea un servizio con questo schema di bundle di modelli di servizio, è possibile accettare i valori predefiniti o fornire valori personalizzati. Anche il parametro `unique_name` è incluso nell'esempio e *non ha* un valore predefinito. È elencato come `required` proprietà (parametro). In qualità di amministratore o sviluppatore, è necessario fornire valori per `required` i parametri quando si creano servizi.
Se desideri creare un modello di servizio con una pipeline di servizi, includilo nello schema. `pipeline_input_type`
**File di schema di servizio di esempio per un servizio che include una pipeline AWS Proton di servizi.**
Questo esempio di schema può essere utilizzato con i file AWS Proton IAc mostrati nell'[Esempio 4 e nell'[Esempio](ag-infrastructure-tmp-files-cloudformation.md#ag-proton-pipeline-cfn-example)](ag-infrastructure-tmp-files-cloudformation.md#ag-proton-svc-cfn-example) 5. È inclusa una pipeline di servizi.
```
schema: # required
format: # required
openapi: "3.0.0" # required
# required defined by administrator
service_input_type: "LoadBalancedServiceInput"
# only include if including AWS Proton service pipeline, defined by administrator
pipeline_input_type: "PipelineInputs"
types: # required
# defined by administrator
LoadBalancedServiceInput:
type: object
description: "Input properties for a loadbalanced Fargate service"
properties:
port: # parameter
type: number
description: "The port to route traffic to"
default: 80
minimum: 0
maximum: 65535
desired_count: # parameter
type: number
description: "The default number of Fargate tasks you want running"
default: 1
minimum: 1
task_size: # parameter
type: string
description: "The size of the task you want to run"
enum: ["x-small", "small", "medium", "large", "x-large"]
default: "x-small"
image: # parameter
type: string
description: "The name/url of the container image"
default: "public.ecr.aws/z9d2n7e1/nginx:1.19.5"
minLength: 1
maxLength: 200
unique_name: # parameter
type: string
description: "The unique name of your service identifier. This will be used to name your log group, task definition and ECS service"
minLength: 1
maxLength: 100
required:
- unique_name
# defined by administrator
PipelineInputs:
type: object
description: "Pipeline input properties"
properties:
dockerfile: # parameter
type: string
description: "The location of the Dockerfile to build"
default: "Dockerfile"
minLength: 1
maxLength: 100
unit_test_command: # parameter
type: string
description: "The command to run to unit test the application code"
default: "echo 'add your unit test command here'"
minLength: 1
maxLength: 200
```
Se desiderate creare un modello di servizio senza una pipeline di servizi, *non includetelo* `pipeline_input_type` nello schema, come illustrato nell'esempio seguente.
**File di schema di servizio di esempio per un servizio che *non* include una pipeline AWS Proton di servizi**
```
schema: # required
format: # required
openapi: "3.0.0" # required
# required defined by administrator
service_input_type: "MyServiceInstanceInputType"
types: # required
# defined by administrator
MyServiceInstanceInputType:
type: object
description: "Service instance input properties"
required:
- my_sample_service_instance_required_input
properties:
my_sample_service_instance_optional_input: # parameter
type: string
description: "This is a sample input"
default: "hello world"
my_sample_service_instance_required_input: # parameter
type: string
description: "Another sample input"
```