Iniziare con AWS CLI - AWS Proton
1. Registrare un modello di ambiente2. Registrare un modello di servizio3. Implementa un ambiente4. Implementare un servizio5. Eliminazione

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

Iniziare con AWS CLI

Per iniziare a AWS Proton usare il AWS CLI, segui questo tutorial. Il tutorial illustra un servizio di carico bilanciato rivolto al pubblico basato su AWS Proton . AWS Fargate Il tutorial fornisce anche una pipeline CI/CD che implementa un sito Web statico con un'immagine visualizzata.

Prima di iniziare, assicurati di essere configurato correttamente. Per informazioni dettagliate, consultare Prerequisiti.

Fase 1: Registrare un modello di ambiente

In questa fase, in qualità di amministratore, registri un modello di ambiente di esempio, che contiene un cluster Amazon Elastic Container Service (AmazonECS) e un Amazon Virtual Private Cloud (AmazonVPC) con due sottoreti pubbliche/private.

Per registrare un modello di ambiente

  1. Inserisci il repository AWS Proton Sample CloudFormation Templates nel tuo GitHub account o organizzazione. Questo repository include i modelli di ambiente e servizio che utilizziamo in questo tutorial.

    Quindi, registra il tuo repository biforcato con. AWS Proton Per ulteriori informazioni, consulta Crea un link al tuo repository.

  2. Crea un modello di ambiente.

    La risorsa del modello di ambiente tiene traccia delle versioni del modello di ambiente.

    $ aws proton create-environment-template \
  --name "fargate-env" \
  --display-name "Public VPC Fargate" \
  --description "VPC with public access and ECS cluster"

  3. Crea una configurazione di sincronizzazione dei modelli.

    AWS Proton imposta una relazione di sincronizzazione tra il repository e il modello di ambiente. Quindi crea la versione 1.0 del modello nello DRAFT stato.

    $ aws proton create-template-sync-config \
  --template-name "fargate-env" \
  --template-type "ENVIRONMENT" \
  --repository-name "your-forked-repo" \
  --repository-provider "GITHUB" \
  --branch "your-branch" \
  --subdirectory "environment-templates/fargate-env"

  4. Attendi che la versione del modello di ambiente venga registrata correttamente.

    Quando questo comando ritorna con uno stato di uscita di0, la registrazione della versione è completa. Ciò è utile negli script per garantire la corretta esecuzione del comando nel passaggio successivo.

    $ aws proton wait environment-template-version-registered \
  --template-name "fargate-env" \
  --major-version "1" \
  --minor-version "0"

  5. Pubblicate la versione del modello di ambiente per renderla disponibile per la creazione dell'ambiente.

    $ aws proton update-environment-template-version \
  --template-name "fargate-env" \
  --major-version "1" \
  --minor-version "0" \
  --status "PUBLISHED"

Fase 2: Registrazione di un modello di servizio

In questa fase, in qualità di amministratore, registri un modello di servizio di esempio, che contiene tutte le risorse necessarie per fornire un servizio Amazon ECS Fargate con un sistema di bilanciamento del carico e una pipeline CI/CD che utilizza. AWS CodePipeline

Per registrare un modello di servizio

  1. Creare un modello di servizio.

    La risorsa del modello di servizio tiene traccia delle versioni del modello di servizio.

    $ aws proton create-service-template \
  --name "load-balanced-fargate-svc" \
  --display-name "Load balanced Fargate service" \
  --description "Fargate service with an application load balancer"

  2. Crea una configurazione di sincronizzazione dei modelli.

    AWS Proton imposta una relazione di sincronizzazione tra il repository e il modello di servizio. Quindi crea la versione 1.0 del modello nello DRAFT stato.

    $ aws proton create-template-sync-config \
  --template-name "load-balanced-fargate-svc" \
  --template-type "SERVICE" \
  --repository-name "your-forked-repo" \
  --repository-provider "GITHUB" \
  --branch "your-branch" \
  --subdirectory "service-templates/load-balanced-fargate-svc"

  3. Attendi che la versione del modello di servizio venga registrata correttamente.

    Quando questo comando ritorna con uno stato di uscita di0, la registrazione della versione è completa. Ciò è utile negli script per garantire la corretta esecuzione del comando nel passaggio successivo.

    $ aws proton wait service-template-version-registered \
  --template-name "load-balanced-fargate-svc" \
  --major-version "1" \
  --minor-version "0"

  4. Pubblica la versione del modello di servizio per renderla disponibile per la creazione del servizio.

    $ aws proton update-service-template-version \
  --template-name "load-balanced-fargate-svc" \
  --major-version "1" \
  --minor-version "0" \
  --status "PUBLISHED"

Fase 3: Implementazione di un ambiente

In questo passaggio, in qualità di amministratore, si crea un'istanza di un AWS Proton ambiente dal modello di ambiente.

Per distribuire un ambiente

  1. Ottieni un file di specifiche di esempio per il modello di ambiente che hai registrato.

    È possibile scaricare il file environment-templates/fargate-env/spec/spec.yaml dal repository di esempio del modello. In alternativa, è possibile recuperare l'intero repository localmente ed eseguire il create-environment comando dalla directory. environment-templates/fargate-env

  2. Crea un ambiente.

    AWS Proton legge i valori di input dalle specifiche dell'ambiente, li combina con il modello di ambiente ed effettua il provisioning delle risorse ambientali nell' AWS account utilizzando il ruolo di servizio dell'utente. AWS Proton 

    $ aws proton create-environment \
  --name "fargate-env-prod" \
  --template-name "fargate-env" \
  --template-major-version 1 \
  --proton-service-role-arn "arn:aws:iam::123456789012:role/AWS ProtonServiceRole" \
  --spec "file://spec/spec.yaml"

  3. Attendi che l'ambiente venga distribuito correttamente.

    $ aws proton wait environment-deployed --name "fargate-env-prod"

Fase 4: Implementazione di un servizio [sviluppatore di applicazioni]

Nei passaggi precedenti, un amministratore ha registrato e pubblicato un modello di servizio e distribuito un ambiente. In qualità di sviluppatore di applicazioni, ora puoi creare un AWS Proton servizio e distribuirlo nell'ambiente AWS Proton

Per distribuire un servizio

  1. Ottieni un file di specifiche di esempio per il modello di servizio registrato dall'amministratore.

    È possibile scaricare il file service-templates/load-balanced-fargate-svc/spec/spec.yaml dal repository di esempio del modello. In alternativa, è possibile recuperare l'intero repository localmente ed eseguire il create-service comando dalla directory. service-templates/load-balanced-fargate-svc

  2. Inserisci il repository di AWS Proton Sample Services nel tuo account o nella tua GitHub organizzazione. Questo repository include il codice sorgente dell'applicazione che utilizziamo in questo tutorial.

  3. Crea un servizio.

    AWS Proton legge i valori di input dalle specifiche del servizio, li combina con il modello di servizio ed effettua il provisioning delle risorse di servizio nell' AWS account nell'ambiente specificato nelle specifiche. Una AWS CodePipeline pipeline distribuisce il codice dell'applicazione dal repository specificato nel comando.

    $ aws proton create-service \
  --name "static-website" \
  --repository-connection-arn \
    "arn:aws:codestar-connections:us-east-1:123456789012:connection/your-codestar-connection-id" \
  --repository-id "your-GitHub-account/aws-proton-sample-services" \
  --branch-name "main" \
  --template-major-version 1 \
  --template-name "load-balanced-fargate-svc" \
  --spec "file://spec/spec.yaml"

  4. Attendi che il servizio venga distribuito correttamente.

    $ aws proton wait service-created --name "static-website"

  5. Recupera gli output e visualizza il tuo nuovo sito web.

    Esegui il comando seguente:

    $ aws proton list-service-instance-outputs \
  --service-name "static-website" \
  --service-instance-name load-balanced-fargate-svc-prod

    L'output del comando dovrebbe essere simile al seguente:

    {
    "outputs": [
        {
            "key": "ServiceURL",
            "valueString": "http://your-service-endpoint.us-east-1.elb.amazonaws.com"
        }
    ]
}

    Il valore dell'output dell'ServiceURListanza è l'endpoint del nuovo sito Web di servizio. Usa il tuo browser per accedervi. Dovresti vedere il seguente grafico su una pagina statica:

    Un browser Web che mostra il sito con immagini statiche risultante dalla CLI procedura introduttiva

Fase 5: Pulizia (opzionale)

In questo passaggio, quando hai finito di esplorare le AWS risorse che hai creato come parte di questo tutorial e per risparmiare sui costi associati a tali risorse, le elimini.

Per eliminare le risorse del tutorial

  1. Per eliminare il servizio, esegui il seguente comando:

    $ aws proton delete-service --name "static-website"

  2. Per eliminare l'ambiente, esegui il comando seguente:

    $ aws proton delete-environment --name "fargate-env-prod"

  3. Per eliminare il modello di servizio, esegui i seguenti comandi:

    $ aws proton delete-template-sync-config \
  --template-name "load-balanced-fargate-svc" \
  --template-type "SERVICE"
$ aws proton delete-service-template --name "load-balanced-fargate-svc"

  4. Per eliminare il modello di ambiente, esegui i seguenti comandi:

    $ aws proton delete-template-sync-config \
  --template-name "fargate-env" \
  --template-type "ENVIRONMENT"
$ aws proton delete-environment-template --name "fargate-env"