Crea una configurazione di sincronizzazione dei modelli - AWS Proton
Modelli di servizio di sincronizzazione

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

Crea una configurazione di sincronizzazione dei modelli

Scopri come creare una configurazione di sincronizzazione dei modelli con AWS Proton.

Crea i prerequisiti di configurazione per la sincronizzazione dei modelli:
Il link al repository è composto da quanto segue:

  • Una CodeConnections connessione che AWS Proton autorizza l'accesso al repository e la sottoscrizione alle relative notifiche.

  • Un ruolo collegato al servizio. Quando colleghi il tuo repository, il ruolo collegato al servizio viene creato automaticamente.

Prima di creare la prima configurazione di sincronizzazione dei modelli, inserisci un pacchetto di modelli nel tuo repository, come mostrato nel seguente layout di directory.

 /templates/                                                 # subdirectory (optional)
 /templates/my-env-template/                                 # template name
 /templates/my-env-template/v1/                              # template version
 /templates/my-env-template/v1/infrastructure/               # template bundle
 /templates/my-env-template/v1/schema/

Dopo aver creato la prima configurazione di sincronizzazione dei modelli, le nuove versioni dei modelli vengono create automaticamente quando invii un commit che aggiunge un pacchetto di modelli aggiornato in una nuova versione (ad esempio, sotto). /my-env-template/v2/

 /templates/                                                 # subdirectory (optional)
 /templates/my-env-template/                                 # template name
 /templates/my-env-template/v1/                              # template version
 /templates/my-env-template/v1/infrastructure/               # template bundle
 /templates/my-env-template/v1/schema/
 /templates/my-env-template/v2/
 /templates/my-env-template/v2/infrastructure/
 /templates/my-env-template/v2/schema/

Puoi includere nuove versioni di pacchetti di modelli per uno o più modelli configurati per la sincronizzazione in un unico commit. AWS Proton crea una nuova versione del modello per ogni nuova versione del pacchetto di modelli inclusa nel commit.

Dopo aver creato la configurazione di sincronizzazione dei modelli, puoi comunque creare manualmente nuove versioni del modello nella console o caricando i pacchetti di modelli AWS CLI da un bucket S3. La sincronizzazione dei modelli funziona solo in una direzione: dal tuo repository a. AWS Proton Le versioni dei modelli create manualmente non vengono sincronizzate.

Dopo aver impostato una configurazione di sincronizzazione dei modelli, AWS Proton ascolta le modifiche al tuo repository. Ogni volta che viene inserita una modifica, cerca una cartella con lo stesso nome del modello. Quindi cerca all'interno di quella directory tutte le directory che assomigliano alle versioni principali. AWS Proton registra il pacchetto di modelli nella versione principale del modello corrispondente. Le nuove versioni sono sempre disponibili nello DRAFT stato. Puoi pubblicare le nuove versioni con la console o AWS CLI.

Ad esempio, supponiamo di avere un modello chiamato my-env-template configurato per la sincronizzazione da my-repo/templates on branch main con il seguente layout.

 /code
 /code/service.go
 README.md
 /templates/
 /templates/my-env-template/
 /templates/my-env-template/v1/
 /templates/my-env-template/v1/infrastructure/
 /templates/my-env-template/v1/schema/
 /templates/my-env-template/v2/
 /templates/my-env-template/v2/infrastructure/
 /templates/my-env-template/v2/schema/

AWS Proton sincronizza il contenuto di /templates/my-env-template/v1/ to my-env-template:1 e il contenuto di /templates/my-env-template/v2/ to. my-env-template:2 Se non esistono già, crea queste versioni principali.

AWS Proton ha trovato la prima directory che corrisponde al nome del modello. È possibile limitare le AWS Proton ricerche nelle directory specificando un subdirectoryPath quando si crea o si modifica una configurazione di sincronizzazione dei modelli. Ad esempio, è possibile specificare per. /production-templates/ subdirectoryPath

È possibile creare una configurazione di sincronizzazione dei modelli utilizzando la console o la CLI.

AWS Management Console
Crea un modello e una configurazione di sincronizzazione dei modelli utilizzando la console.

  1. Nella AWS Proton console, scegli Modelli di ambiente.

  2. Scegli Crea modello di ambiente.

  3. Nella pagina Crea modello di ambiente, nella sezione Opzioni modello, scegli Crea un modello per il provisioning di nuovi ambienti.

  4. Nella sezione Sorgente del pacchetto di modelli, scegli Sincronizza modelli da Git.

  5. Nella sezione Archivio del codice sorgente:

    1. Per Repository, seleziona l'archivio collegato che contiene il tuo pacchetto di modelli.

    2. Per Branch, seleziona un ramo del repository da cui eseguire la sincronizzazione.

    3. (Facoltativo) Per la directory dei pacchetti di modelli, inserite il nome di una directory per delimitare la ricerca del pacchetto di modelli.

  6. Nella sezione Dettagli del modello.

    1. Inserisci un Nome del modello.

    2. (Facoltativo) Inserite un nome da visualizzare per il modello.

    3. (Facoltativo) Inserite una descrizione del modello per il modello di ambiente.

  7. (Facoltativo) Seleziona la casella di controllo Personalizza le impostazioni di crittografia (avanzate) nella sezione Impostazioni di crittografia per fornire la tua chiave di crittografia.

  8. (Facoltativo) Nella sezione Tag, scegli Aggiungi nuovo tag e inserisci una chiave e un valore per creare un tag gestito dal cliente.

  9. Scegli il modello Create Environment.

    Ora ti trovi 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 e gestiti dai clienti. AWS Proton genera automaticamente tag AWS gestiti per te quando crei AWS Proton risorse. Per ulteriori informazioni, consulta AWS Protonrisorse e Tagging.

  10. Nella pagina dei dettagli del modello, scegli la scheda Sincronizzazione per visualizzare i dati di dettaglio della configurazione della sincronizzazione del modello.

  11. Scegli la scheda Versioni del modello per visualizzare le versioni del modello con i dettagli sullo stato.

  12. Lo stato di un nuovo modello di ambiente inizia nello stato Bozza. Tu e altre persone con proton:CreateEnvironment autorizzazioni potete visualizzarlo e accedervi. Segui il passaggio successivo per rendere il modello disponibile agli altri.

  13. Nella sezione Versioni del modello, scegli il pulsante di opzione a sinistra della versione secondaria del modello che hai appena creato (1.0). In alternativa, puoi scegliere Pubblica nell'avviso informativo e saltare il passaggio successivo.

  14. Nella sezione Versioni dei modelli, scegli Pubblica.

  15. Lo stato del modello cambia in Pubblicato. È la versione più recente e consigliata del modello.

  16. Nel riquadro di navigazione, seleziona Modelli di ambiente per visualizzare un elenco dei modelli e dei dettagli dell'ambiente.

La procedura per creare un modello di servizio e una configurazione di sincronizzazione dei modelli è simile.

AWS CLI
Crea un modello e una configurazione di sincronizzazione dei modelli utilizzando AWS CLI.
  1. Crea un modello. In questo esempio, viene creato un modello di ambiente.

    Esegui il comando seguente.

    $ aws proton create-environment-template \
    --name "env-template"

    La risposta è la seguente.

    {
    "environmentTemplate": {
        "arn": "arn:aws:proton:us-east-1:123456789012:environment-template/env-template",
        "createdAt": "2021-11-07T23:32:43.045000+00:00",
        "displayName": "env-template",
        "lastModifiedAt": "2021-11-07T23:32:43.045000+00:00",
        "name": "env-template",
        "status": "DRAFT",
        "templateName": "env-template"
    }
}
  2. Crea la configurazione di sincronizzazione dei modelli con AWS CLI fornendo quanto segue:

    • Il modello con cui vuoi sincronizzarti. Dopo aver creato la configurazione di sincronizzazione dei modelli, puoi comunque crearne nuove versioni manualmente nella console o con AWS CLI.

    • Il nome del modello.

    • Il tipo di modello.

    • L'archivio collegato da cui desideri eseguire la sincronizzazione.

    • Il fornitore di repository collegato.

    • La filiale in cui si trova il pacchetto di modelli.

    • (Facoltativo) Il percorso della directory contenente il pacchetto di modelli. Per impostazione predefinita, AWS Proton cerca la prima directory che corrisponde al nome del modello.

    Esegui il comando seguente.

    $ aws proton create-template-sync-config \
    --template-name "env-template" \
    --template-type "ENVIRONMENT" \
    --repository-name "myrepos/templates" \
    --repository-provider "GITHUB" \
    --branch "main" \
    --subdirectory "env-template/"

    La risposta è la seguente.

    {
    "templateSyncConfigDetails": {
        "branch": "main",
        "repositoryName": "myrepos/templates",
        "repositoryProvider": "GITHUB",
        "subdirectory": "templates",
        "templateName": "env-template",
        "templateType": "ENVIRONMENT"
    }
}

  3. Per pubblicare la versione del modello, consultaRegistrazione e pubblicazione di modelli.

Modelli di servizio di sincronizzazione

Gli esempi precedenti mostrano come sincronizzare i modelli di ambiente. I modelli di servizio sono simili. Per sincronizzare i modelli di servizio, aggiungi un file aggiuntivo denominato .template-registration.yaml a ciascuna directory delle versioni principali del pacchetto di modelli. Questo file contiene dettagli aggiuntivi AWS Proton necessari quando crea una versione del modello di servizio a seguito di un commit. Quando crei esplicitamente una versione di modello di servizio utilizzando la AWS Proton console o l'API, fornisci questi dettagli come input e questo file sostituisce questi input per la sincronizzazione del modello.

./templates/                                                 # subdirectory (optional)
 /templates/my-svc-template/                                 # service template name
 /templates/my-svc-template/v1/                              # service template version
 /templates/my-svc-template/v1/.template-registration.yaml   # service template version properties
 /templates/my-svc-template/v1/instance_infrastructure/      # template bundle
 /templates/my-svc-template/v1/schema/

Il .template-registration.yaml file contiene i seguenti dettagli:

  • Ambienti compatibili [richiesto]: gli ambienti basati su questi modelli di ambiente e le versioni principali sono compatibili con i servizi basati su questa versione del modello di servizio.

  • Fonti di componenti supportate [opzionale]: i componenti che utilizzano queste fonti sono compatibili con i servizi basati su questa versione del modello di servizio. Se non specificato, i componenti non possono essere collegati a questi servizi. Per ulteriori informazioni sui componenti, vedereAWS Proton componenti .

La sintassi YAML del file è la seguente:

compatible_environments:
  - env-templ-name:major-version
  - ...
supported_component_sources:
  - DIRECTLY_DEFINED

Specificate una o più combinazioni di modelli di ambiente/versioni principali. supported_component_sourcesLa specificazione è facoltativa e l'unico valore supportato èDIRECTLY_DEFINED.

Esempio .template-registration.yaml

In questo esempio, la versione del modello di servizio è compatibile con le versioni principali 1 e 2 del modello di ambiente. my-env-template È anche compatibile con le versioni principali 1 e 3 del modello di another-env-template ambiente. Il file non specificasupported_component_sources, quindi i componenti non possono essere allegati ai servizi basati su questa versione del modello di servizio.

compatible_environments:
  - my-env-template:1
  - my-env-template:2
  - another-env-template:1
  - another-env-template:3
Nota

In precedenza, AWS Proton definiva un file diverso.compatible-envs, per specificare ambienti compatibili. AWS Proton supporta ancora quel file e il suo formato per la compatibilità con le versioni precedenti. Non è più consigliabile utilizzarlo, perché non è estensibile e non può supportare funzionalità più recenti come i componenti.