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 la [AWS Proton Service Deprecation and Migration Guide. ](https://docs.aws.amazon.com/proton/latest/userguide/proton-end-of-support.html)
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à.
# Registra e pubblica i modelli
È possibile registrare e pubblicare modelli di ambiente e servizio con AWS Proton, come descritto nelle sezioni seguenti.
È possibile creare una nuova versione di un modello con la console o AWS CLI.
In alternativa, puoi utilizzare la console o AWS CLI creare un modello e [ configurarne ](ag-template-sync-configs.md) la sincronizzazione. Questa configurazione consente la AWS Proton sincronizzazione dai pacchetti di modelli che si trovano nei repository git registrati che hai definito. Ogni volta che viene inviato un commit al tuo repository che modifica uno dei tuoi bundle di modelli, viene creata una nuova versione minore o principale del modello, se la versione non esiste già. Per saperne di più sui prerequisiti e sui requisiti di configurazione della sincronizzazione dei modelli, consulta. [Configurazioni di sincronizzazione dei modelli](ag-template-sync-configs.md)
## Registra e pubblica modelli di ambiente
È possibile registrare e pubblicare i seguenti tipi di modelli di ambiente.
+ Registra e pubblica un modello di * ambiente * standard AWS Proton utilizzato per distribuire e gestire l'infrastruttura ambientale.
+ Registra e pubblica un modello di * ambiente gestito dal * cliente che AWS Proton utilizza per connettersi all'infrastruttura di provisioning esistente che gestisci. AWS Proton *non * gestisce l'infrastruttura di provisioning esistente.
**Importante**
In qualità di amministratore, assicurati che l'infrastruttura fornita e gestita e tutti i parametri di output siano compatibili con i modelli di * ambiente gestiti * dal cliente associati. AWS Proton non posso tenere conto delle modifiche per tuo conto perché queste modifiche non sono visibili. AWS Proton Le incoerenze si traducono in errori.
È possibile utilizzare la console o la AWS CLI per registrare e pubblicare un modello di ambiente.
------
#### [ Console di gestione AWS ]
**Usa la console per registrare e pubblicare un nuovo modello di ambiente.**
1. Nella [AWS Proton console](https://console.aws.amazon.com/proton/), scegli Modelli di ** ambiente**.
1. Scegli ** Crea modello di ambiente**.
1. Nella ** pagina ** Crea modello di ambiente, nella ** sezione Opzioni ** modello, scegli una delle due opzioni di modello disponibili.
+ **Crea un modello per il provisioning di nuovi ambienti. **
+ **Crea un modello per utilizzare l'infrastruttura predisposta che gestisci. **
1. Se hai scelto ** Crea un modello per il provisioning di nuovi ambienti**, nella ** sezione ** Template bundle source, scegli una delle tre opzioni di origine del template bundle disponibili. Per ulteriori informazioni sui requisiti e sui prerequisiti per la sincronizzazione dei modelli, consulta. [Configurazioni di sincronizzazione dei modelli](ag-template-sync-configs.md)
+ **Utilizza uno dei nostri pacchetti di modelli di esempio. **
+ **Usa il tuo pacchetto ** di modelli.
+ **[Sincronizza i modelli da Git ](ag-template-sync-configs.md)**.
1.
**Fornisci un percorso a un pacchetto di modelli.**
1. Se hai scelto ** Utilizza uno dei nostri pacchetti ** di modelli di esempio:
Nella ** sezione Pacchetto ** di modelli di esempio, seleziona un pacchetto di modelli di esempio.
1. Se hai scelto ** Sincronizza i modelli da Git**, nella sezione Codice ** sorgente: **
1. Seleziona il repository per la configurazione della sincronizzazione dei modelli.
1. Inserisci il nome del ramo del repository da cui eseguire la sincronizzazione.
1. (Facoltativo) Inserisci il nome di una directory per limitare la ricerca del pacchetto di modelli.
1. Altrimenti, nella ** sezione relativa alla posizione del pacchetto ** S3, fornisci un percorso al pacchetto di modelli.
1. Nella sezione Dettagli del ** modello. **
1. Inserisci un **Nome del modello**.
1. (Facoltativo) Inserisci il nome visualizzato del ** modello**.
1. (Facoltativo) Inserite una descrizione del ** modello ** per il modello di ambiente.
1. (Facoltativo) Seleziona la casella di controllo ** Personalizza le impostazioni di crittografia (avanzate) ** nella ** sezione Impostazioni di ** crittografia per fornire la tua chiave di crittografia.
1. (Facoltativo) Nella ** sezione ** Tag, scegli ** Aggiungi nuovo tag ** e inserisci una chiave e un valore per creare un tag gestito dal cliente.
1. Scegli il modello ** Crea ambiente**.
Ora sei su una nuova pagina che mostra lo stato e i dettagli del tuo nuovo modello di ambiente. Questi dettagli includono un elenco di tag AWS gestiti dal cliente. AWS Proton genera automaticamente tag AWS gestiti per te quando crei AWS Proton risorse. Per ulteriori informazioni, consulta [AWS Proton risorse e tag](resources.md).
1. Lo stato di un nuovo stato del modello di ambiente inizia nello ** stato ** Bozza. Tu e gli altri utenti con `proton:CreateEnvironment` autorizzazioni potete visualizzarlo e accedervi. Segui il passaggio successivo per rendere il modello disponibile ad altri.
1. Nella ** sezione Versioni del ** modello, scegli il pulsante di opzione a sinistra della versione secondaria del modello appena creato (1.0). In alternativa, puoi scegliere ** Pubblica ** nell'avviso informativo e saltare il passaggio successivo.
1. Nella ** sezione Versioni del ** modello, scegli ** Pubblica**.
1. Lo stato del modello cambia in ** Pubblicato**. Poiché è l'ultima versione del modello, è la ** versione ** consigliata.
1. Nel riquadro di navigazione, seleziona Modelli di ** ambiente ** per visualizzare un elenco dei modelli e dei dettagli dell'ambiente.
**Usa la console per registrare nuove versioni principali e secondarie di un modello di ambiente.**
Per ulteriori informazioni, consulta [Modelli con versione](ag-template-versions.md).
1. Nella [AWS Proton console](https://console.aws.amazon.com/proton/), scegli ** Environment Templates**.
1. Nell'elenco dei modelli di ambiente, scegli il nome del modello di ambiente per il quale desideri creare una versione principale o secondaria.
1. Nella vista dettagliata del modello di ambiente, scegli ** Crea nuova versione ** nella ** sezione Versioni del ** modello.
1. Nella ** pagina ** Crea una nuova versione del modello di ambiente, nella ** sezione Fonte del pacchetto di ** modelli, scegli una delle due opzioni di origine del pacchetto di modelli disponibili.
+ **Utilizza uno dei nostri pacchetti di modelli di esempio. **
+ **Usa il tuo pacchetto ** di modelli.
1. Fornisci un percorso al pacchetto di modelli selezionato.
+ Se hai scelto ** Utilizza uno dei nostri pacchetti di modelli di esempio**, nella ** sezione Pacchetto di modelli di ** esempio, seleziona un pacchetto di modelli di esempio.
+ Se hai scelto ** Usa il tuo pacchetto di modelli**, nella ** sezione Posizione del pacchetto ** S3, scegli il percorso del pacchetto di modelli.
1. Nella sezione Dettagli del modello. ** **
1. (Facoltativo) Inserisci il nome visualizzato del ** modello**.
1. (Facoltativo) Inserite una descrizione del ** modello ** per il modello di servizio.
1. Nella ** sezione Dettagli del ** modello, scegli una delle seguenti opzioni.
+ Per creare una versione secondaria, tieni ** vuota la ** casella di controllo Seleziona per creare una nuova versione principale.
+ Per creare una versione principale, seleziona la ** casella di controllo Seleziona per creare una nuova versione principale**.
1. Continua con i passaggi della console per creare la nuova versione secondaria o principale e scegli ** Crea nuova versione**.
------
#### [ AWS CLI ]
**Usa la CLI per registrare e pubblicare un nuovo modello di ambiente, come mostrato nei passaggi seguenti.**
1. Crea un modello di * ambiente * OR gestito dal * cliente * standard specificando la regione, il nome, il nome visualizzato (opzionale) e la descrizione (opzionale).
1. Crea un modello * di * ambiente standard.
Esegui il comando seguente:
```
$ aws proton create-environment-template \
--name "{{simple-env}}" \
--display-name "{{Fargate}}" \
--description "{{VPC with public access}}"
```
Risposta:
```
{
"environmentTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env",
"createdAt": "2020-11-11T23:02:45.336000+00:00",
"description": "VPC with public access",
"displayName": "VPC",
"lastModifiedAt": "2020-11-11T23:02:45.336000+00:00",
"name": "simple-env"
}
}
```
1. Crea un modello di * ambiente gestito dal * cliente aggiungendo il `provisioning` parametro con valore`CUSTOMER_MANAGED`.
Esegui il comando seguente:
```
$ aws proton create-environment-template \
--name "{{simple-env}}" \
--display-name "{{Fargate}}" \
--description "{{VPC with public access}}" \
--provisioning "CUSTOMER_MANAGED"
```
Risposta:
```
{
"environmentTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env",
"createdAt": "2020-11-11T23:02:45.336000+00:00",
"description": "VPC with public access",
"displayName": "VPC",
"lastModifiedAt": "2020-11-11T23:02:45.336000+00:00",
"name": "simple-env",
"provisioning": "CUSTOMER_MANAGED"
}
}
```
1.
**Crea una versione secondaria 0 della versione principale 1 del modello di ambiente**
Questo e i passaggi rimanenti sono gli stessi sia per i modelli di * ambiente * standard * che per quelli gestiti * dal cliente.
Includi il nome del modello, la versione principale e il nome e la chiave del bucket S3 per il bucket che contiene il pacchetto di modelli di ambiente.
Esegui il comando seguente:
```
$ aws proton create-environment-template-version \
--template-name "{{simple-env}}" \
--description "{{Version 1}}" \
--source s3="{bucket={{your_s3_bucket}}, key={{your_s3_key}}}"
```
Risposta:
```
{
"environmentTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-11T23:02:47.763000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:47.763000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"status": "REGISTRATION_IN_PROGRESS",
"templateName": "simple-env"
}
}
```
1. Usa il comando get per controllare lo stato delle registrazioni.
Esegui il comando seguente:
```
$ aws proton get-environment-template-version \
--template-name "{{simple-env}}" \
--major-version "{{1}}" \
--minor-version "{{0}}"
```
Risposta:
```
{
"environment": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-11T23:02:47.763000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:47.763000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n environment_input_type: \"MyEnvironmentInputType\"\n types:\n MyEnvironmentInputType:\n type: object\n description: \"Input properties for my environment\"\n properties:\n my_sample_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_other_sample_input:\n type: string\n description: \"Another sample input\"\n required:\n - my_other_sample_input\n",
"status": "DRAFT",
"statusMessage": "",
"templateName": "simple-env"
}
}
```
1. Pubblica la versione secondaria 0 della versione principale 1 del modello di ambiente fornendo il nome del modello e la versione principale e secondaria. Questa versione è la `Recommended` versione.
Esegui il comando seguente:
```
$ aws proton update-environment-template-version \
--template-name "{{simple-env}}" \
--major-version "{{1}}" \
--minor-version "{{0}}" \
--status "{{PUBLISHED}}"
```
Risposta:
```
{
"environmentTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:environment-template/simple-env:1.0",
"createdAt": "2020-11-11T23:02:47.763000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:54.610000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n environment_input_type: \"MyEnvironmentInputType\"\n types:\n MyEnvironmentInputType:\n type: object\n description: \"Input properties for my environment\"\n properties:\n my_sample_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_other_sample_input:\n type: string\n description: \"Another sample input\"\n required:\n - my_other_sample_input\n",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "simple-env"
}
}
```
Dopo aver creato un nuovo modello utilizzando il AWS CLI, è possibile visualizzare un elenco di tag AWS gestiti dal cliente. AWS Proton genera automaticamente tag AWS gestiti per te. Puoi anche modificare e creare tag gestiti dai clienti utilizzando AWS CLI. Per ulteriori informazioni, consulta [AWS Proton risorse e tag](resources.md).
Esegui il comando seguente:
```
$ aws proton list-tags-for-resource \
--resource-arn "arn:aws:proton:{{region-id}}:{{123456789012}}:environment-template/{{simple-env}}"
```
------
## Registra e pubblica modelli di servizio
Quando si crea una versione del modello di servizio, si specifica un elenco di modelli di ambiente compatibili. In questo modo, quando gli sviluppatori selezionano un modello di servizio, possono scegliere l'ambiente in cui distribuire il servizio.
Prima di creare un servizio da un modello di servizio o prima di pubblicare un modello di servizio, verificate che gli ambienti siano distribuiti a partire dai modelli di ambiente compatibili elencati.
Non è * possibile * aggiornare un servizio alla nuova versione principale se è distribuito in un ambiente creato a partire da un modello di ambiente compatibile rimosso.
Per aggiungere o rimuovere modelli di ambiente compatibili per una versione del modello di servizio, è necessario crearne una nuova versione principale.
È possibile utilizzare la console o la AWS CLI per registrare e pubblicare un modello di servizio.
------
#### [ Console di gestione AWS ]
**Usa la console per registrare e pubblicare un nuovo modello di servizio.**
1. Nella [AWS Proton console](https://console.aws.amazon.com/proton/), scegli Modelli ** di servizio**.
1. Scegli ** Crea modello di servizio**.
1. Nella ** pagina ** Crea modello di servizio, nella ** sezione ** Template bundle source, scegli una delle opzioni di modello disponibili.
+ **Usa il tuo pacchetto ** di modelli.
+ **Sincronizza i modelli da Git**.
1.
**Fornisci un percorso a un pacchetto di modelli.**
1. Se hai scelto ** Sincronizza i modelli da Git**, nella sezione ** Source code repository**:
1. Seleziona il repository per la configurazione della sincronizzazione dei modelli.
1. Inserisci il nome del ramo del repository da cui eseguire la sincronizzazione.
1. (Facoltativo) Inserisci il nome di una directory per limitare la ricerca del pacchetto di modelli.
1. Altrimenti, nella ** sezione relativa alla posizione del pacchetto ** S3, fornisci un percorso al pacchetto di modelli.
1. Nella sezione Dettagli del ** modello. **
1. Inserisci un **Nome del modello**.
1. (Facoltativo) Inserisci il nome visualizzato del ** modello**.
1. (Facoltativo) Inserite una descrizione del ** modello ** per il modello di servizio.
1. Nella ** sezione Modelli di ambiente ** compatibili, scegli da un elenco di modelli di ambiente compatibili.
1. (Facoltativo) Nella ** sezione Impostazioni di ** crittografia, scegli ** Personalizza le impostazioni di crittografia (avanzate) ** per fornire la tua chiave di crittografia.
1. (Facoltativo) Nella ** sezione ** Pipeline:
Se non includi una definizione di pipeline di servizi nel modello di servizio, deseleziona la ** casella di controllo ** Pipeline - opzionale nella parte inferiore della pagina. Non * puoi * modificarlo dopo aver creato il modello di servizio. Per ulteriori informazioni, consulta [Pacchetti di modelli](ag-template-authoring.md#ag-template-bundles).
1. (Facoltativo) Nella ** sezione Sorgenti dei componenti ** supportate, per Origini dei ** componenti**, scegli Definito ** direttamente ** per abilitare il collegamento di componenti definiti direttamente alle tue istanze di servizio.
1. (Facoltativo) Nella ** sezione ** Tag, scegli ** Aggiungi nuovo tag ** e inserisci una chiave e un valore per creare un tag gestito dal cliente.
1. Scegli ** Crea un modello di servizio**.
Ora ti trovi in una nuova pagina che mostra lo stato e i dettagli del tuo nuovo modello di servizio. Questi dettagli includono un elenco di tag AWS gestiti dal cliente. AWS Proton genera automaticamente tag AWS gestiti per te quando crei AWS Proton risorse. Per ulteriori informazioni, consulta [AWS Proton risorse e tag](resources.md).
1. Lo stato di un nuovo stato del modello di servizio inizia nello ** stato ** Bozza. Tu e gli altri utenti con `proton:CreateService` autorizzazioni potete visualizzarlo e accedervi. Segui il passaggio successivo per rendere il modello disponibile ad altri.
1. Nella ** sezione Versioni del ** modello, scegli il pulsante di opzione a sinistra della versione secondaria del modello appena creato (1.0). In alternativa, puoi scegliere ** Pubblica ** nell'avviso informativo e saltare il passaggio successivo.
1. Nella ** sezione Versioni del ** modello, scegli ** Pubblica**.
1. Lo stato del modello cambia in ** Pubblicato**. Poiché è l'ultima versione del modello, è la ** versione ** consigliata.
1. Nel riquadro di navigazione, seleziona Modelli di ** servizio ** per visualizzare un elenco dei modelli e dei dettagli del servizio.
**Usa la console per registrare nuove versioni principali e secondarie di un modello di servizio.**
Per ulteriori informazioni, consulta [Modelli con versione](ag-template-versions.md).
1. Nella [AWS Proton console](https://console.aws.amazon.com/proton/), scegli Modelli ** di servizio**.
1. Nell'elenco dei modelli di servizio, scegli il nome del modello di servizio per il quale desideri creare una versione principale o secondaria.
1. Nella vista dettagliata del modello di servizio, scegli ** Crea nuova versione ** nella ** sezione Versioni del ** modello.
1. Nella ** pagina ** Crea una nuova versione del modello di servizio, nella ** sezione sorgente del ** pacchetto, seleziona ** Usa il tuo pacchetto ** di modelli.
1. Nella ** sezione Posizione del pacchetto ** S3, scegli il percorso del tuo pacchetto di modelli.
1. Nella sezione Dettagli del ** modello. **
1. (Facoltativo) Inserisci il nome visualizzato del ** modello**.
1. (Facoltativo) Inserite una descrizione del ** modello ** per il modello di servizio.
1. Nella ** sezione Dettagli del ** modello, scegli una delle seguenti opzioni.
+ Per creare una versione secondaria, tieni ** vuota la ** casella di controllo Seleziona per creare una nuova versione principale.
+ Per creare una versione principale, seleziona la ** casella di controllo Seleziona per creare una nuova versione principale**.
1. Continua con i passaggi della console per creare la nuova versione secondaria o principale e scegli ** Crea nuova versione**.
------
#### [ AWS CLI ]
Per creare un modello di servizio che distribuisca un servizio senza una pipeline di servizi, aggiungi il parametro e il `create-service-template` valore `--pipeline-provisioning "CUSTOMER_MANAGED"` al comando. Configura i pacchetti di modelli come descritto in [Pacchetti di modelli](ag-template-authoring.md#ag-template-bundles) creazione e. [Requisiti dello schema per i pacchetti di modelli di servizio](ag-schema.md#schema-req-svc)
**Nota**
Non è possibile modificare `pipelineProvisioning` dopo la creazione del modello di servizio.
1.
**Usa la CLI per registrare e pubblicare un nuovo modello di servizio, con o senza una pipeline di servizi, come mostrato nei passaggi seguenti.**
1.
**Crea un modello di servizio con una pipeline di servizi utilizzando la CLI.**
Specifica il nome, il nome visualizzato (opzionale) e la descrizione (opzionale).
Esegui il comando seguente:
```
$ aws proton create-service-template \
--name "{{fargate-service}}" \
--display-name "{{Fargate}}" \
--description "{{Fargate-based Service}}"
```
Risposta:
```
{
"serviceTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service",
"createdAt": "2020-11-11T23:02:55.551000+00:00",
"description": "Fargate-based Service",
"displayName": "Fargate",
"lastModifiedAt": "2020-11-11T23:02:55.551000+00:00",
"name": "fargate-service"
}
}
```
1.
**Crea un modello di servizio senza una pipeline di servizi.**
Add `--pipeline-provisioning`.
Esegui il comando seguente:
```
$ aws proton create-service-template \
--name "{{fargate-service}}" \
--display-name "{{Fargate}}" \
--description "{{Fargate-based Service}}" \
--pipeline-provisioning "CUSTOMER_MANAGED"
```
Risposta:
```
{
"serviceTemplate": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service",
"createdAt": "2020-11-11T23:02:55.551000+00:00",
"description": "Fargate-based Service",
"displayName": "Fargate",
"lastModifiedAt": "2020-11-11T23:02:55.551000+00:00",
"name": "fargate-service",
"pipelineProvisioning": "CUSTOMER_MANAGED"
}
}
```
1.
**Crea una versione secondaria 0 della versione principale 1 del modello di servizio.**
Includi il nome del modello, i modelli di ambiente compatibili, la versione principale e il nome e la chiave del bucket S3 per il bucket che contiene il pacchetto del modello di servizio.
Esegui il comando seguente:
```
$ aws proton create-service-template-version \
--template-name "{{fargate-service}}" \
--description "{{Version 1}}" \
--source s3="{bucket={{your_s3_bucket}}, key={{your_s3_key}}}" \
--compatible-environment-templates '[{"templateName":"{{simple-env}}","majorVersion":"{{1}}"}]'
```
Risposta:
```
{
"serviceTemplateMinorVersion": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:57.912000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"status": "REGISTRATION_IN_PROGRESS",
"templateName": "fargate-service"
}
}
```
1. Usa il * comando * get per controllare lo stato delle registrazioni.
Esegui il comando seguente:
```
$ aws proton get-service-template-version \
--template-name "{{fargate-service}}" \
--major-version "{{1}}" \
--minor-version "{{0}}"
```
Risposta:
```
{
"serviceTemplateMinorVersion": {
"arn": "arn:aws:proton:us-east-1:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:57.912000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n pipeline_input_type: \"MyPipelineInputType\"\n service_input_type: \"MyServiceInstanceInputType\"\n\n types:\n MyPipelineInputType:\n type: object\n description: \"Pipeline input properties\"\n required:\n - my_sample_pipeline_required_input\n properties:\n my_sample_pipeline_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_pipeline_required_input:\n type: string\n description: \"Another sample input\"\n\n MyServiceInstanceInputType:\n type: object\n description: \"Service instance input properties\"\n required:\n - my_sample_service_instance_required_input\n properties:\n my_sample_service_instance_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_service_instance_required_input:\n type: string\n description: \"Another sample input\"",
"status": "DRAFT",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
1. Pubblica il modello di servizio utilizzando il comando update per modificare lo stato in. `"PUBLISHED"`
Esegui il comando seguente:
```
$ aws proton update-service-template-version \
--template-name "{{fargate-service}}" \
--description "{{Version 1}}" \
--major-version "{{1}}" \
--minor-version "{{0}}" \
--status "{{PUBLISHED}}"
```
Risposta:
```
{
"serviceTemplateVersion": {
"arn": "arn:aws:proton:region-id:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:02:57.912000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"recommendedMinorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n pipeline_input_type: \"MyPipelineInputType\"\n service_input_type: \"MyServiceInstanceInputType\"\n\n types:\n MyPipelineInputType:\n type: object\n description: \"Pipeline input properties\"\n required:\n - my_sample_pipeline_required_input\n properties:\n my_sample_pipeline_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello pipeline\"\n my_sample_pipeline_required_input:\n type: string\n description: \"Another sample input\"\n\n MyServiceInstanceInputType:\n type: object\n description: \"Service instance input properties\"\n required:\n - my_sample_service_instance_required_input\n properties:\n my_sample_service_instance_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_service_instance_required_input:\n type: string\n description: \"Another sample input\"\n",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
1. Verifica che sia AWS Proton stata pubblicata la versione 1.0 utilizzando il comando get per recuperare i dati di dettaglio del modello di servizio.
Esegui il comando seguente:
```
$ aws proton get-service-template-version \
--template-name "{{fargate-service}}" \
--major-version "{{1}}" \
--minor-version "{{0}}"
```
Risposta:
```
{
"serviceTemplateMinorVersion": {
"arn": "arn:aws:proton:us-east-1:123456789012:service-template/fargate-service:1.0",
"compatibleEnvironmentTemplates": [
{
"majorVersion": "1",
"templateName": "simple-env"
}
],
"createdAt": "2020-11-11T23:02:57.912000+00:00",
"description": "Version 1",
"lastModifiedAt": "2020-11-11T23:03:04.767000+00:00",
"majorVersion": "1",
"minorVersion": "0",
"schema": "schema:\n format:\n openapi: \"3.0.0\"\n pipeline_input_type: \"MyPipelineInputType\"\n service_input_type: \"MyServiceInstanceInputType\"\n\n types:\n MyPipelineInputType:\n type: object\n description: \"Pipeline input properties\"\n required:\n - my_sample_pipeline_required_input\n properties:\n my_sample_pipeline_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_pipeline_required_input:\n type: string\n description: \"Another sample input\"\n\n MyServiceInstanceInputType:\n type: object\n description: \"Service instance input properties\"\n required:\n - my_sample_service_instance_required_input\n properties:\n my_sample_service_instance_optional_input:\n type: string\n description: \"This is a sample input\"\n default: \"hello world\"\n my_sample_service_instance_required_input:\n type: string\n description: \"Another sample input\"",
"status": "PUBLISHED",
"statusMessage": "",
"templateName": "fargate-service"
}
}
```
------