View a markdown version of this page

Création d'une configuration de synchronisation de modèles - AWS Proton
Modèles de services de synchronisation

Avis de fin de support : le 7 octobre 2026, AWS le support pour AWS Proton. Après le 7 octobre 2026, vous ne pourrez plus accéder à la AWS Proton console ni aux AWS Proton ressources. Votre infrastructure déployée restera intacte. Pour plus d'informations, consultez le Guide AWS Proton de dépréciation et de migration des services.

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.

Création d'une configuration de synchronisation de modèles

Apprenez à créer une configuration de synchronisation de modèles avec AWS Proton.

Configuration requise pour créer un modèle de synchronisation :
Le lien vers le référentiel comprend les éléments suivants :

  • Une CodeConnections connexion qui donne AWS Proton l'autorisation d'accéder à votre référentiel et de vous abonner à ses notifications.

  • Un rôle lié à un service. Lorsque vous liez votre référentiel, le rôle lié au service est créé pour vous.

Avant de créer votre première configuration de synchronisation de modèles, transférez un ensemble de modèles vers votre référentiel, comme indiqué dans le schéma de répertoire suivant.

 /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/

Une fois que vous avez créé votre première configuration de synchronisation de modèles, de nouvelles versions de modèles sont automatiquement créées lorsque vous envoyez un commit qui ajoute un ensemble de modèles mis à jour sous une nouvelle version (par exemple, sous/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/

Vous pouvez inclure de nouvelles versions de bundle de modèles pour un ou plusieurs modèles configurés pour la synchronisation dans un seul commit. AWS Proton crée une nouvelle version de modèle pour chaque nouvelle version de bundle de modèles incluse dans le commit.

Après avoir créé la configuration de synchronisation des modèles, vous pouvez toujours créer manuellement de nouvelles versions du modèle dans la console ou en AWS CLI téléchargeant des ensembles de modèles depuis un compartiment S3. La synchronisation des modèles ne fonctionne que dans un seul sens : de votre référentiel vers AWS Proton. Les versions de modèles créées manuellement ne sont pas synchronisées.

Après avoir configuré une configuration de synchronisation des modèles, AWS Proton écoute les modifications apportées à votre référentiel. Chaque fois qu'une modification est apportée, elle recherche tout répertoire portant le même nom que votre modèle. Il recherche ensuite dans ce répertoire tous les répertoires qui ressemblent à des versions majeures. AWS Proton enregistre le bundle de modèles dans la version majeure du modèle correspondant. Les nouvelles versions sont toujours en l'DRAFTétat. Vous pouvez publier les nouvelles versions à l'aide de la console ou AWS CLI.

Par exemple, supposons que vous ayez un modèle appelé my-env-template configuré pour être synchronisé depuis my-repo/templates une branche main avec la mise en page suivante.

 /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 synchronise le contenu de /templates/my-env-template/v1/ to my-env-template:1 et le contenu de /templates/my-env-template/v2/ tomy-env-template:2. S'ils n'existent pas déjà, il crée ces versions majeures.

AWS Proton a trouvé le premier répertoire correspondant au nom du modèle. Vous pouvez limiter les AWS Proton recherches dans les annuaires en spécifiant le subdirectoryPath moment où vous créez ou modifiez une configuration de synchronisation de modèles. Par exemple, vous pouvez spécifier /production-templates/ poursubdirectoryPath.

Vous pouvez créer une configuration de synchronisation de modèles à l'aide de la console ou de l'interface de ligne de commande.

Console de gestion AWS
Créez un modèle et une configuration de synchronisation des modèles à l'aide de la console.

  1. Dans la AWS Proton console, choisissez Modèles d'environnement.

  2. Choisissez Créer un modèle d'environnement.

  3. Sur la page Créer un modèle d'environnement, dans la section Options du modèle, choisissez Créer un modèle pour le provisionnement de nouveaux environnements.

  4. Dans la section Source du bundle de modèles, choisissez Synchroniser les modèles depuis Git.

  5. Dans la section Référentiel du code source :

    1. Pour Référentiel, sélectionnez le référentiel lié qui contient votre ensemble de modèles.

    2. Pour Branche, sélectionnez la branche du référentiel à partir de laquelle vous souhaitez effectuer la synchronisation.

    3. (Facultatif) Pour le répertoire des ensembles de modèles, entrez le nom d'un répertoire pour affiner la recherche de votre ensemble de modèles.

  6. Dans la section Détails du modèle.

    1. Saisissez un Template name (Nom de modèle).

    2. (Facultatif) Entrez un nom d'affichage du modèle.

    3. (Facultatif) Entrez une description du modèle pour le modèle d'environnement.

  7. (Facultatif) Cochez la case Personnaliser les paramètres de cryptage (avancés) dans la section Paramètres de cryptage pour fournir votre propre clé de cryptage.

  8. (Facultatif) Dans la section Tags, choisissez Ajouter un nouveau tag et entrez une clé et une valeur pour créer un tag géré par le client.

  9. Choisissez Créer un modèle d'environnement.

    Vous êtes maintenant sur une nouvelle page qui affiche l'état et les détails de votre nouveau modèle d'environnement. Ces informations incluent une liste des balises AWS gérées et gérées par le client. AWS Proton génère automatiquement des balises AWS gérées pour vous lorsque vous créez des AWS Proton ressources. Pour de plus amples informations, veuillez consulter AWS Proton ressources et balisage.

  10. Dans la page détaillée du modèle, choisissez l'onglet Synchronisation pour afficher les données détaillées de configuration de la synchronisation du modèle.

  11. Cliquez sur l'onglet Versions des modèles pour afficher les versions des modèles avec les détails de leur statut.

  12. Le statut d'un nouveau modèle d'environnement commence à l'état Brouillon. Vous et les autres personnes proton:CreateEnvironment autorisées pouvez le consulter et y accéder. Procédez à l'étape suivante pour mettre le modèle à la disposition des autres utilisateurs.

  13. Dans la section Versions des modèles, cliquez sur le bouton radio situé à gauche de la version mineure du modèle que vous venez de créer (1.0). Vous pouvez également choisir Publier dans l'alerte d'information et sauter l'étape suivante.

  14. Dans la section Versions des modèles, choisissez Publier.

  15. Le statut du modèle passe à Publié. Il s'agit de la version la plus récente et recommandée du modèle.

  16. Dans le volet de navigation, sélectionnez Modèles d'environnement pour afficher la liste des modèles et des détails de votre environnement.

La procédure de création d'un modèle de service et la configuration de synchronisation des modèles sont similaires.

AWS CLI
Créez un modèle et une configuration de synchronisation des modèles à l'aide du AWS CLI.
  1. Créez un modèle. Dans cet exemple, un modèle d'environnement est créé.

    Exécutez la commande suivante.

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

    La réponse est la suivante.

    {
    "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. Créez votre configuration de synchronisation de modèles avec AWS CLI en fournissant les éléments suivants :

    • Le modèle avec lequel vous souhaitez effectuer la synchronisation. Après avoir créé la configuration de synchronisation des modèles, vous pouvez toujours créer de nouvelles versions à partir de celle-ci manuellement dans la console ou à l'aide du AWS CLI.

    • Nom du modèle.

    • Type de modèle.

    • Le référentiel lié à partir duquel vous souhaitez effectuer la synchronisation.

    • Le fournisseur du référentiel lié.

    • Branche dans laquelle se trouve le bundle de modèles.

    • (Facultatif) Le chemin d'accès au répertoire contenant votre ensemble de modèles. Par défaut, AWS Proton recherche le premier répertoire qui correspond au nom de votre modèle.

    Exécutez la commande suivante.

    $ 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 réponse est la suivante.

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

  3. Pour publier la version de votre modèle, consultezEnregistrer et publier des modèles.

Modèles de services de synchronisation

Les exemples précédents montrent comment synchroniser les modèles d'environnement. Les modèles de service sont similaires. Pour synchroniser les modèles de service, vous ajoutez un fichier supplémentaire nommé .template-registration.yaml dans chaque répertoire de versions principales de votre ensemble de modèles. Ce fichier contient les informations supplémentaires AWS Proton nécessaires lors de la création d'une version de modèle de service pour vous à la suite d'une validation. Lorsque vous créez explicitement une version de modèle de service à l'aide de la AWS Proton console ou de l'API, vous fournissez ces informations sous forme d'entrées, et ce fichier remplace ces entrées pour la synchronisation des modèles.

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

Le .template-registration.yaml fichier contient les informations suivantes :

  • Environnements compatibles [obligatoire] — Les environnements basés sur ces modèles d'environnement et les versions principales sont compatibles avec les services basés sur cette version de modèle de service.

  • Sources de composants prises en charge [facultatif] — Les composants utilisant ces sources sont compatibles avec les services basés sur cette version de modèle de service. Si ce n'est pas spécifié, les composants ne peuvent pas être associés à ces services. Pour plus d'informations sur les composants, consultezAWS Proton components.

La syntaxe YAML du fichier est la suivante :

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

Spécifiez une ou plusieurs combinaisons modèle d'environnement/version majeure. supported_component_sourcesLa spécification est facultative et la seule valeur prise en charge estDIRECTLY_DEFINED.

Exemple.template-registration.yaml

Dans cet exemple, la version du modèle de service est compatible avec les versions principales 1 et 2 du modèle d'my-env-templateenvironnement. Il est également compatible avec les principales versions 1 et 3 du modèle d'another-env-templateenvironnement. Le fichier ne le précise passupported_component_sources, de sorte que les composants ne peuvent pas être attachés à des services basés sur cette version de modèle de service.

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

Précédemment, vous avez AWS Proton défini un autre fichier.compatible-envs,, pour spécifier des environnements compatibles. AWS Proton prend toujours en charge ce fichier et son format pour des raisons de compatibilité descendante. Nous vous recommandons de ne plus l'utiliser, car il n'est pas extensible et ne peut pas prendre en charge les nouvelles fonctionnalités telles que les composants.