Commencer à utiliser le AWS CLI - AWS Proton
1. Enregistrer un modèle d'environnement2. Enregistrer un modèle de service3. Déployer un environnement4. Déployer un service5. Nettoyage

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Commencer à utiliser le AWS CLI

Pour commencer à AWS Proton utiliser le AWS CLI, suivez ce didacticiel. Le didacticiel présente un AWS Proton service d'équilibrage de charge destiné au public basé sur. AWS Fargate Le didacticiel fournit également un pipeline CI/CD qui déploie un site Web statique avec une image affichée.

Avant de commencer, assurez-vous que vous êtes correctement configuré. Pour plus de détails, consultez Prérequis.

Étape 1 : enregistrer un modèle d'environnement

Au cours de cette étape, en tant qu'administrateur, vous enregistrez un exemple de modèle d'environnement, qui contient un cluster Amazon Elastic Container Service (AmazonECS) et un Amazon Virtual Private Cloud (AmazonVPC) avec deux sous-réseaux publics/privés.

Pour enregistrer un modèle d'environnement

  1. Intégrez le référentiel AWS Proton d'exemples CloudFormation de modèles à votre GitHub compte ou à votre organisation. Ce référentiel inclut les modèles d'environnement et de service que nous utilisons dans ce didacticiel.

    Enregistrez ensuite votre dépôt bifurqué auprès AWS Proton de. Pour de plus amples informations, veuillez consulter Créez un lien vers votre référentiel.

  2. Créez un modèle d'environnement.

    La ressource du modèle d'environnement suit les versions du modèle d'environnement.

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

  3. Créez une configuration de synchronisation de modèles.

    AWS Proton définit une relation de synchronisation entre votre référentiel et votre modèle d'environnement. Il crée ensuite la version 1.0 du modèle dans DRAFT status.

    $ 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. Attendez que la version du modèle d'environnement soit correctement enregistrée.

    Lorsque cette commande revient avec un statut de sortie de0, l'enregistrement de la version est terminé. Cela est utile dans les scripts pour garantir que vous pouvez exécuter correctement la commande à l'étape suivante.

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

  5. Publiez la version du modèle d'environnement pour la rendre disponible pour la création de l'environnement.

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

Étape 2 : enregistrer un modèle de service

Au cours de cette étape, en tant qu'administrateur, vous enregistrez un exemple de modèle de service, qui contient toutes les ressources nécessaires pour fournir un service Amazon ECS Fargate via un équilibreur de charge et un pipeline CI/CD qui utilise. AWS CodePipeline

Pour enregistrer un modèle de service

  1. Créez un modèle de service.

    La ressource de modèle de service suit les versions des modèles de service.

    $ 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. Créez une configuration de synchronisation de modèles.

    AWS Proton définit une relation de synchronisation entre votre référentiel et votre modèle de service. Il crée ensuite la version 1.0 du modèle dans DRAFT status.

    $ 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. Attendez que la version du modèle de service soit correctement enregistrée.

    Lorsque cette commande revient avec un statut de sortie de0, l'enregistrement de la version est terminé. Cela est utile dans les scripts pour garantir que vous pouvez exécuter correctement la commande à l'étape suivante.

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

  4. Publiez la version du modèle de service pour la rendre disponible pour la création du service.

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

Étape 3 : Déploiement d'un environnement

Au cours de cette étape, en tant qu'administrateur, vous instanciez un AWS Proton environnement à partir du modèle d'environnement.

Pour déployer un environnement

  1. Obtenez un exemple de fichier de spécifications pour le modèle d'environnement que vous avez enregistré.

    Vous pouvez télécharger le fichier environment-templates/fargate-env/spec/spec.yaml depuis le référentiel d'exemples de modèles. Vous pouvez également récupérer l'intégralité du référentiel localement et exécuter la create-environment commande depuis le environment-templates/fargate-env répertoire.

  2. Créez un environnement.

    AWS Proton lit les valeurs d'entrée de votre spécification d'environnement, les combine avec votre modèle d'environnement et provisionne les ressources environnementales de votre AWS compte en utilisant votre rôle de AWS Proton service.

    $ 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. Attendez que l'environnement soit correctement déployé.

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

Étape 4 : Déployer un service [développeur d'applications]

Au cours des étapes précédentes, un administrateur a enregistré et publié un modèle de service et a déployé un environnement. En tant que développeur d'applications, vous pouvez désormais créer un AWS Proton service et le déployer dans l' AWS Proton environnement

Pour déployer un service

  1. Obtenez un exemple de fichier de spécifications pour le modèle de service enregistré par l'administrateur.

    Vous pouvez télécharger le fichier service-templates/load-balanced-fargate-svc/spec/spec.yaml depuis le référentiel d'exemples de modèles. Vous pouvez également récupérer l'intégralité du référentiel localement et exécuter la create-service commande depuis le service-templates/load-balanced-fargate-svc répertoire.

  2. Intégrez le référentiel AWS Proton Sample Services à votre GitHub compte ou à votre organisation. Ce référentiel inclut le code source de l'application que nous utilisons dans ce didacticiel.

  3. Créer un service.

    AWS Proton lit les valeurs d'entrée de votre spécification de service, les combine avec votre modèle de service et fournit les ressources de service de votre AWS compte dans l'environnement spécifié dans la spécification. Un AWS CodePipeline pipeline déploie le code de votre application à partir du référentiel que vous spécifiez dans la commande.

    $ 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. Attendez que le service soit correctement déployé.

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

  5. Récupérez les résultats et consultez votre nouveau site Web.

    Exécutez la commande suivante :

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

    Le résultat de la commande doit être similaire à ce qui suit :

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

    La valeur de la sortie de l'ServiceURLinstance est le point de terminaison de votre nouveau site Web de service. Utilisez votre navigateur pour y accéder. Vous devriez voir le graphique suivant sur une page statique :

    Un navigateur Web affichant le site d'images statiques résultant de la CLI procédure de démarrage

Étape 5 : Nettoyage (facultatif)

Au cours de cette étape, lorsque vous avez terminé d'explorer les AWS ressources que vous avez créées dans le cadre de ce didacticiel, et pour économiser sur les coûts associés à ces ressources, vous les supprimez.

Pour supprimer les ressources du didacticiel

  1. Pour supprimer le service, exécutez la commande suivante :

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

  2. Pour supprimer l'environnement, exécutez la commande suivante :

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

  3. Pour supprimer le modèle de service, exécutez les commandes suivantes :

    $ 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. Pour supprimer le modèle d'environnement, exécutez les commandes suivantes :

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