

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à.

# Utilizzo dei tipi di modifica del provisioning () CTs
<a name="deploy-new-aog"></a>

AMS è responsabile dell'infrastruttura gestita, per apportare modifiche è necessario inviare una RFC con la classificazione CT corretta (categoria, sottocategoria, articolo e operazione). Questa sezione descrive come trovarne CTs, determinare se una TAC è adatta alle proprie esigenze e richiedere una nuova TC se nessuna lo è.

## Verifica se una TAC esistente soddisfa i tuoi requisiti
<a name="ct-check-aog"></a>

Dopo aver determinato cosa vuoi implementare con AMS, il passo successivo consiste nello studiare i CloudFormation modelli esistenti CTs e quelli esistenti per vedere se esiste già una soluzione. 

Quando si crea un RFC, è necessario specificare il CT. È possibile utilizzare Console di gestione AWS o l'API/CLI AMS. Di seguito vengono descritti alcuni esempi di utilizzo di entrambi.

È possibile utilizzare la console o il API/CLI per trovare una modifica del tipo di ID (CT) o della versione. Esistono due metodi: la ricerca o la scelta della classificazione. Per entrambi i tipi di selezione, è possibile ordinare la ricerca scegliendo Usato **più di frequente, Usato** **più di recente** o **Alfabetico**.

**YouTube Video**: [Come posso creare una RFC utilizzando la CLI di AWS Managed Services e dove posso trovare lo schema CT](https://www.youtube.com/watch?v=IluDFwnJJFU&list=PLhr1KZpdzukc_VXASRqOUSM5AJgtHat6-&index=3&t=150s)? 

Nella console AMS, nella **RFCs**pagina -> **Crea RFC:**
+ Con l'opzione **Sfoglia per tipo di modifica** selezionata (impostazione predefinita), puoi:
  + Utilizza l'area di **creazione rapida** per selezionare tra i più diffusi di AMS CTs. Fai clic su un'etichetta e si apre la pagina **Esegui RFC** con l'opzione **Oggetto** compilata automaticamente per te. Completa le opzioni rimanenti secondo necessità e fai clic su **Esegui** per inviare la RFC. 
  + In alternativa, scorri verso il basso fino all'area **Tutti i tipi di modifica** e inizia a digitare un nome CT nella casella delle opzioni, non è necessario avere il nome esatto o completo del tipo di modifica. Puoi anche cercare un CT in base alla modifica dell'ID del tipo, alla classificazione o alla modalità di esecuzione (automatica o manuale) inserendo le parole pertinenti.

    Con la visualizzazione **Carte** predefinita selezionata, le schede CT corrispondenti vengono visualizzate durante la digitazione, seleziona una scheda e fai clic su **Crea RFC**. Con la vista **Tabella** selezionata, scegli il CT pertinente e fai clic su **Crea RFC**. Entrambi i metodi aprono la pagina **Run RFC**.
+ In alternativa, e per esplorare le opzioni di modifica, fai clic su **Scegli per categoria nella** parte superiore della pagina per aprire una serie di caselle di opzioni a discesa.
+ **Scegli una **categoria**, una **sottocategoria**, un **articolo** e un'operazione.** Viene visualizzata la casella delle informazioni per quel tipo di modifica e nella parte inferiore della pagina viene visualizzato un pannello.
+ Quando sei pronto, premi **Invio** per visualizzare un elenco dei tipi di modifica corrispondenti.
+ Scegli un tipo di modifica dall'elenco. La casella delle informazioni per quel tipo di modifica viene visualizzata nella parte inferiore della pagina.
+ Dopo aver impostato il tipo di modifica corretto, scegli **Crea RFC**.
**Nota**  
Affinché questi comandi funzionino, è necessario installare l'AMS CLI. Per installare l'API o la CLI AMS, vai alla pagina **Risorse per gli sviluppatori** della console AMS. Per materiale di riferimento sull'API AMS CM o sull'API AMS SKMS, consulta la sezione AMS Information Resources nella Guida per l'utente. Potrebbe essere necessario aggiungere un'`--profile`opzione per l'autenticazione, `aws amsskms {{ams-cli-command}} --profile SAML` ad esempio. Potrebbe essere necessario aggiungere l'`--region`opzione anche perché tutti i comandi AMS non utilizzano us-east-1, ad esempio. `aws amscm {{ams-cli-command}} --region=us-east-1`
**Nota**  
Gli endpoint AMS API/CLI (amscm e amsskms) si trovano nella regione AWS della Virginia settentrionale,. `us-east-1` A seconda di come è impostata l'autenticazione e della regione AWS in cui si trovano l'account e le risorse, potrebbe essere necessario aggiungerli `--region us-east-1` quando si emettono i comandi. Potrebbe anche essere necessario aggiungere`--profile saml`, se questo è il metodo di autenticazione utilizzato.

Per cercare un tipo di modifica utilizzando l'API AMS CM (vedi [ListChangeTypeClassificationSummaries](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_ListChangeTypeClassificationSummaries.html)) o la CLI:

Puoi utilizzare un filtro o una query per effettuare la ricerca. L' ListChangeTypeClassificationSummaries operazione dispone delle opzioni di [filtro](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_ListChangeTypeClassificationSummaries.html#amscm-ListChangeTypeClassificationSummaries-request-Filters) per `Category``Subcategory`,`Item`, e`Operation`, ma i valori devono corrispondere esattamente ai valori esistenti. Per risultati più flessibili quando si utilizza la CLI, è possibile utilizzare l'`--query`opzione. 


**Filtraggio dei cambi di tipo con l'API/CLI AMS CM**  
<a name="ct-filtering-table"></a>
<table>
<thead>
  <tr><th>Attributo</th><th>Valori validi</th><th>Condizione valida/predefinita</th><th>Note</th></tr>
</thead>
<tbody>
  <tr><td>ChangeTypeId</td><td>Qualsiasi stringa che rappresenta un ChangeTypeId (ad esempio: ct-abc123xyz7890)</td><td>Equals</td><td>[Per il tipo di modifica, vedere il riferimento al tipo di modifica. IDs](https://docs.aws.amazon.com/managedservices/latest/ctref/index.html)<br />Per il tipo di modifica IDs, vedere Finding a Change Type o CSIO.</td></tr>
  <tr><td>Categoria</td><td rowspan="4">Qualsiasi testo in formato libero</td><td rowspan="4">Contiene</td><td rowspan="4">Le espressioni regolari in ogni singolo campo non sono supportate. Ricerca senza distinzione tra lettere maiuscole</td></tr>
  <tr><td>Sottocategoria</td></tr>
  <tr><td>Elemento</td></tr>
  <tr><td>Operazione</td></tr>
</tbody>
</table>


1. Ecco alcuni esempi di classificazione dei tipi di modifica delle inserzioni:

   Il comando seguente elenca tutte le categorie dei tipi di modifica.

   ```
   aws amscm list-change-type-categories
   ```

   Il comando seguente elenca le sottocategorie appartenenti a una categoria specificata.

   ```
   aws amscm list-change-type-subcategories --category {{CATEGORY}}
   ```

   Il comando seguente elenca gli elementi appartenenti a una categoria e sottocategoria specificate.

   ```
   aws amscm list-change-type-items --category {{CATEGORY}} --subcategory {{SUBCATEGORY}}
   ```

1. Ecco alcuni esempi di ricerca dei tipi di modifica con le query CLI:

   Il comando seguente cerca nei riepiloghi delle classificazioni CT quelli che contengono «S3" nel nome dell'elemento e crea l'output della categoria, della sottocategoria, dell'elemento, dell'operazione e dell'ID del tipo di modifica sotto forma di tabella. 

   ```
   aws amscm list-change-type-classification-summaries --query "ChangeTypeClassificationSummaries [?contains(Item, 'S3')].[Category,Subcategory,Item,Operation,ChangeTypeId]" --output table
   ```

   ```
   +---------------------------------------------------------------+
   |               ListChangeTypeClassificationSummaries           |
   +----------+-------------------------+--+------+----------------+
   |Deployment|Advanced Stack Components|S3|Create|ct-1a68ck03fn98r|
   +----------+-------------------------+--+------+----------------+
   ```

1. È quindi possibile utilizzare l'ID del tipo di modifica per ottenere lo schema CT ed esaminare i parametri. Il comando seguente genera lo schema in un file JSON denominato Creates3Params.schema.json.

   ```
   aws amscm get-change-type-version --change-type-id "ct-1a68ck03fn98r" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateS3Params.schema.json
   ```

   [Per informazioni sull'utilizzo delle query CLI, vedere [Come filtrare l'output con l'opzione --query e il](https://docs.aws.amazon.com/cli/latest/userguide/controlling-output.html#controlling-output-filter) riferimento al linguaggio di interrogazione, Specificazione. JMESPath ](http://jmespath.org/specification.html)

1. Dopo aver ottenuto l'ID del tipo di modifica, ti consigliamo di verificare la versione del tipo di modifica per assicurarti che sia la versione più recente. Usa questo comando per trovare la versione per un tipo di modifica specificato:

   ```
   aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value={{CHANGE_TYPE_ID}}
   ```

   Per trovare la versione `AutomationStatus` per un tipo di modifica specifico, esegui questo comando:

   ```
   aws amscm --profile saml get-change-type-version --change-type-id {{CHANGE_TYPE_ID}} --query "ChangeTypeVersion.{AutomationStatus:AutomationStatus.Name}"
   ```

   Per trovare il tipo di modifica `ExpectedExecutionDurationInMinutes` per un tipo di modifica specifico, esegui questo comando:

   ```
   aws amscm --profile saml get-change-type-version --change-type-id ct-14027q0sjyt1h --query "ChangeTypeVersion.{ExpectedDuration:ExpectedExecutionDurationInMinutes}"
   ```

Una volta trovato un CT che ritieni appropriato, esamina lo schema JSON dei parametri di esecuzione ad esso associato per scoprire se è adatto al tuo caso d'uso. 

Utilizzate questo comando per generare uno schema CT in un file JSON che prende il nome dal CT; questo esempio restituisce lo schema di archiviazione Create S3:

`aws amscm get-change-type-version --change-type-id "ct-1a68ck03fn98r" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateBucketParams.json`

Diamo un'occhiata più da vicino a ciò che offre questo schema.


**S3 Bucket Crea schema**  


- ** 

```
{	
  "$schema": "http://json-schema.org/draft-04/schema#",
"name": "Create S3 Storage  
"description": "Use to create an Amazon Simple Storage Service stack.",
  "type": "object",
  "properties": {
    "Description": {
      "description": "The description of the stack.",
      "type": "string",
      "minLength": 1,
      "maxLength": 500
    },
    "VpcId": {
      "description": "ID of the VPC to create the S3 Bucket in, in the form vpc-a1b2c3d4e5f67890e.",
      "type": "string",
      "pattern": "^vpc-[a-z0-9]{17}$"
    },
    "StackTemplateId": {
      "description": "Required value: stm-s2b72beb000000000.",
      "type": "string",
      "enum": ["stm-s2b72beb000000000"]
    },
    "Name":{
      "description": "The name of the stack to create.",
      "type": "string",
      "minLength": 1,
      "maxLength": 255
    },
    "Tags": {
      "description": "Up to seven tags (key/value pairs) for the stack.",
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "Key": {
            "type": "string",
            "minLength": 1,
            "maxLength": 127
          },
          "Value": {
            "type": "string",
            "minLength": 1,
            "maxLength": 255
          }
        },
        "additionalProperties": false,
        "required": [
          "Key",
          "Value"
        ]
      },
      "minItems": 1,
      "maxItems": 7
    },
    "TimeoutInMinutes": {
      "description": "The amount of time, in minutes, to allow for creation of the stack.",
      "type": "number",
      "minimum": 0,
      "maximum": 60
    },
    "Parameters": {
      "description": "Specifications for the stack.",
      "type": "object",
      "properties": {
        "AccessControl": {
          "description": "The canned (predefined) access control list (ACL) to assign to the bucket.",
          "type": "string",
          "enum": [
            "Private",
            "PublicRead",
            "AuthenticatedRead",
            "BucketOwnerRead"
          ]
        },
        "BucketName": {
          "description": "A name for the bucket. The bucket name must contain only lowercase letters, numbers, periods (.), and hyphens (-).",
          "type": "string",
          "pattern": "^[a-z0-9]([-.a-z0-9]+)[a-z0-9]$",
          "minLength": 3,
          "maxLength": 63
        }
      },
      "additionalProperties": false,
      "required": [
        "AccessControl",
        "BucketName"
      ]
    }
  },
  "additionalProperties": false,
  "required": [
    "Description",
    "VpcId",
    "StackTemplateId",
    "Name",
    "TimeoutInMinutes",
    "Parameters"
  ]
}
``` **
  - Lo schema inizia con CT («descrizione»), che indica a cosa serve lo schema. In questo caso, per creare uno stack di archiviazione S3.<br />Successivamente, sono disponibili proprietà obbligatorie e facoltative che è possibile specificare. Vengono forniti i valori predefiniti delle proprietà. Le proprietà richieste sono elencate alla fine dello schema.<br />Nell' StackTemplateId area, si vede che esiste un modello di stack specifico per questo CT e lo schema e il relativo ID è un valore di proprietà obbligatorio.<br />Lo schema consente di etichettare lo stack che si sta creando, per scopi di contabilità interna. Inoltre, alcune opzioni, come backup, richiedono un tag di tipo key:backup e value:TRUE. Per informazioni approfondite, leggi [Tagging Your Amazon EC2 Resources](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html). <br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br />
  - La sezione Parametri dello schema CT JSON è dove fornisci i parametri di esecuzione. <br />Per questo schema, BucketName sono richiesti solo l'ACL e i parametri di esecuzione.



## Richiedi un nuovo CT
<a name="request-new-ct-aog"></a>

Dopo aver esaminato lo schema, potresti decidere che non fornisce parametri sufficienti per creare la distribuzione desiderata. In tal caso, esamina i CloudFormation modelli esistenti per trovarne uno più vicino a quello desiderato. Una volta individuati i parametri aggiuntivi necessari, invia un messaggio Gestione \| Altro \| Altro \| Crea CT.

**Nota**  
All Other \| Other Create and Update CTs riceve l'attenzione di un operatore AMS, che ti contatterà per discutere del nuovo CT.

Per inviare una richiesta per un nuovo CT, accedi alla console AMS tramite la normale procedura [Console di gestione AWS](https://aws.amazon.com/console/)e segui questi passaggi.

1. Dalla barra di navigazione a sinistra, fai clic su **RFCs**.

   Si apre la pagina del RFCs pannello di controllo.

1. Fai clic su **Create (Crea)**.

   Viene visualizzata la pagina Crea una richiesta di modifica.

1. **Seleziona Gestione nell'elenco a discesa **Categoria** e Altro per la **sottocategoria e l'articolo**.** Per l'**operazione, scegli Crea**. La RFC avrà bisogno dell'approvazione prima di poter essere implementata.

1. Inserisci le informazioni sul motivo per cui desideri il CT, ad esempio: richiesta di un CT di archiviazione Create S3 modificato che consenta la personalizzazione ACLs, in base al CT di archiviazione Create S3 esistente. Ciò dovrebbe comportare un nuovo CT: Deployment \| Advanced Stack Components \| S3 storage \| Create S3 custom ACL. Questo nuovo CT potrebbe essere pubblico.

1. Fare clic su **Submit (Invia)**.

   Il tuo RFC viene visualizzato sulla dashboard RFC.

## Prova il nuovo CT
<a name="test-new-ct-aog"></a>

Una volta che AWS Managed Services ha creato il nuovo CT, lo testerai inviando una RFC. Se hai collaborato con AMS per rendere preapprovata la nuova CT, puoi semplicemente seguire una richiesta RFC standard e controllare il risultato (per i dettagli sull'invio RFCs, consulta [Creazione](https://docs.aws.amazon.com/managedservices/latest/userguide/create-rfcs.html) e invio di una RFC). Se il nuovo CT non è preapprovato (vuoi essere sicuro che non venga mai eseguito senza un'approvazione esplicita), dovrai discuterne l'implementazione con AMS ogni volta che vuoi eseguirlo.