1. Enregistrer un modèle d'environnement 2. Enregistrer un modèle de service 3. Déployer un environnement 4. Déployer un service 5. Nettoyage

Démarrer avec le kit AWS CLI

Pour commencer à AWS Proton utiliser leAWS 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 (Amazon ECS) et un Amazon Virtual Private Cloud (Amazon VPC) avec deux sous-réseaux publics/privés.

Pour enregistrer un modèle d'environnement

Intégrez le référentiel AWS Protond'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 plus d'informations, veuillez consulter Créez un lien vers votre référentiel.

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"

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

AWS Protondé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"

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"
```

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

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"

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

AWS Protondé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"

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"
```

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éployer 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

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.
Créez un environnement.

AWS Protonlit 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/AWSProtonServiceRole" \
  --spec "file://spec/spec.yaml"
```

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 Protonenvironnement

Pour déployer un service

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.
Intégrez le référentiel AWS ProtonSample Services à votre GitHub compte ou à votre organisation. Ce référentiel inclut le code source de l'application que nous utilisons dans ce didacticiel.

Créer un service.

AWS Protonlit 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"

Attendez que le service soit correctement déployé.


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

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 :

É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

Pour supprimer le service, exécutez la commande suivante :
```
$ aws proton delete-service --name "static-website"
```
Pour supprimer l'environnement, exécutez la commande suivante :
```
$ aws proton delete-environment --name "fargate-env-prod"
```

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"

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"

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Mise en route avec la console

Bibliothèque de modèles