AWS CloudFormation Exemple de composant - AWS Proton
Étapes de l'administrateurÉtapes pour les développeurs

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.

AWS CloudFormation Exemple de composant

Voici un exemple complet d'un composant AWS Proton directement défini et de la façon dont vous pouvez l'utiliser dans un AWS Proton service. Le composant fournit un bucket Amazon Simple Storage Service (Amazon S3) et la politique d'accès associée. L'instance de service peut faire référence à ce compartiment et l'utiliser. Le nom du compartiment est basé sur les noms de l'environnement, du service, de l'instance de service et du composant, ce qui signifie que le compartiment est couplé à une instance spécifique du modèle de composant étendant une instance de service spécifique. Les développeurs peuvent créer plusieurs composants sur la base de ce modèle de composant, afin de fournir des compartiments Amazon S3 pour différentes instances de service et différents besoins fonctionnels.

L'exemple couvre la création des différents fichiers d' AWS CloudFormation infrastructure sous forme de code (IaC) requis et la création d'un rôle requis AWS Identity and Access Management (IAM). L'exemple regroupe les étapes en fonction des rôles des personnes propriétaires.

Étapes de l'administrateur

Pour permettre aux développeurs d'utiliser des composants avec un service

  1. Créez un rôle AWS Identity and Access Management (IAM) qui délimite les ressources que les composants directement définis exécutés dans votre environnement peuvent fournir. AWS Proton assume ce rôle ultérieurement pour approvisionner des composants directement définis dans l'environnement.

    Pour cet exemple, utilisez la politique suivante :

    Exemple rôle de composant directement défini
    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "cloudformation:CancelUpdateStack",
        "cloudformation:CreateChangeSet",
        "cloudformation:DeleteChangeSet",
        "cloudformation:DescribeStacks",
        "cloudformation:ContinueUpdateRollback",
        "cloudformation:DetectStackResourceDrift",
        "cloudformation:DescribeStackResourceDrifts",
        "cloudformation:DescribeStackEvents",
        "cloudformation:CreateStack",
        "cloudformation:DeleteStack",
        "cloudformation:UpdateStack",
        "cloudformation:DescribeChangeSet",
        "cloudformation:ExecuteChangeSet",
        "cloudformation:ListChangeSets",
        "cloudformation:ListStackResources"
      ],
      "Resource": "arn:aws:cloudformation:*:123456789012:stack/AWSProton-*"
    },
    {
      "Effect": "Allow",
      "Action": [
        "s3:CreateBucket",
        "s3:DeleteBucket",
        "s3:GetBucket",
        "iam:CreatePolicy",
        "iam:DeletePolicy",
        "iam:GetPolicy",
        "iam:ListPolicyVersions",
        "iam:DeletePolicyVersion"
      ],
      "Resource": "*",
      "Condition": {
        "ForAnyValue:StringEquals": {
          "aws:CalledVia": "cloudformation.amazonaws.com"
        }
      }
    }
  ]
}

  2. Indiquez le rôle que vous avez créé à l'étape précédente lorsque vous créez ou mettez à jour l'environnement. Dans la AWS Proton console, spécifiez un rôle de composant sur la page Configurer l'environnement. Si vous utilisez l' AWS Proton API ou AWS CLI, spécifiez l'une CreateEnvironmentou l'componentRoleArnautre des actions de UpdateEnvironmentl'API.

  3. Créez un modèle de service qui fait référence à un composant directement défini attaché à l'instance de service.

    L'exemple montre comment écrire un modèle de service robuste qui ne se brise pas si aucun composant n'est attaché à l'instance de service.

    Exemple fichier CloudFormation IaC de service utilisant un composant
    # service/instance_infrastructure/cloudformation.yaml

Resources: 
  TaskDefinition:
    Type: AWS::ECS::TaskDefinition
    Properties:
      TaskRoleArn: !Ref TaskRole
      ContainerDefinitions:
        - Name: '{{service_instance.name}}'
          # ...
          {% if service_instance.components.default.outputs | length > 0 %}
          Environment:
            {{ service_instance.components.default.outputs |
                proton_cfn_ecs_task_definition_formatted_env_vars }}
          {% endif %}

  # ...

  TaskRole:
    Type: AWS::IAM::Role
    Properties:
      # ...
      ManagedPolicyArns:
        - !Ref BaseTaskRoleManagedPolicy
        {{ service_instance.components.default.outputs
            | proton_cfn_iam_policy_arns }}

  # Basic permissions for the task
  BaseTaskRoleManagedPolicy:
    Type: AWS::IAM::ManagedPolicy
    Properties:
      # ...

  4. Créez une nouvelle version mineure du modèle de service qui déclare que les composants directement définis sont pris en charge.

    • Ensemble de modèles dans Amazon S3 — Dans la AWS Proton console, lorsque vous créez une version de modèle de service, pour Sources de composants prises en charge, sélectionnez Directement défini. Si vous utilisez l' AWS Proton API ou AWS CLI, spécifiez-le DIRECTLY_DEFINED dans le supportedComponentSources paramètre des actions de l'UpdateServiceTemplateVersionAPI CreateServiceTemplateVersionou.

    • Synchronisation des modèles — Apportez une modification à votre référentiel de packs de modèles de services, que vous spécifiez supported_component_sources: en DIRECTLY_DEFINED tant qu'élément du .template-registration.yaml fichier dans le répertoire des versions principales. Pour de plus amples informations sur ce fichier, veuillez consulter Modèles de service de synchronisation.

  5. Publiez la nouvelle version mineure du modèle de service. Pour de plus amples informations, veuillez consulter Enregistrez et publiez des modèles.

  6. Assurez-vous d'autoriser les proton:CreateComponent développeurs qui utilisent ce modèle de service à jouer le rôle IAM.

Étapes pour les développeurs

Pour utiliser un composant directement défini avec une instance de service

  1. Créez un service qui utilise la version du modèle de service créée par l'administrateur avec le support des composants. Vous pouvez également mettre à jour l'une de vos instances de service existantes pour utiliser la dernière version du modèle.

  2. Rédigez un fichier modèle de composant iAC qui approvisionne un compartiment Amazon S3 et une politique d'accès associée et expose ces ressources sous forme de sorties.

    Exemple fichier CloudFormation iAC du composant
    # cloudformation.yaml

# A component that defines an S3 bucket and a policy for accessing the bucket.
Resources:
  S3Bucket:
    Type: 'AWS::S3::Bucket'
    Properties:
      BucketName: '{{environment.name}}-{{service.name}}-{{service_instance.name}}-{{component.name}}'
  S3BucketAccessPolicy:
    Type: AWS::IAM::ManagedPolicy
    Properties:
      PolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: Allow
            Action:
              - 's3:Get*'
              - 's3:List*'
              - 's3:PutObject'
            Resource: !GetAtt S3Bucket.Arn
Outputs:
  BucketName:
    Description: "Bucket to access"
    Value: !GetAtt S3Bucket.Arn
  BucketAccessPolicyArn:
    Value: !Ref S3BucketAccessPolicy

  3. Si vous utilisez l' AWS Proton API AWS CLI, rédigez un fichier manifeste pour le composant.

    Exemple manifeste de composant défini directement
    infrastructure:
  templates:
    - file: "cloudformation.yaml"
      rendering_engine: jinja
      template_language: cloudformation

  4. Créez un composant directement défini. AWS Proton assume le rôle de composant défini par l'administrateur pour provisionner le composant.

    Dans la AWS Proton console, sur la page Composants, choisissez Créer un composant. Pour les paramètres du composant, entrez un nom de composant et une description du composant facultative. Pour Attacher un composant, choisissez Attacher le composant à une instance de service. Sélectionnez votre environnement, votre service et votre instance de service. Pour Source du composant, choisissez AWS CloudFormation, puis choisissez le fichier iAC du composant.

    Note

    Il n'est pas nécessaire de fournir un manifeste : la console en crée un pour vous.

    Si vous utilisez l' AWS Proton API ou AWS CLI utilisez l'action CreateComponentAPI. Définissez un composant name et optionneldescription. Set environmentNameserviceName, etserviceInstanceName. Définissez templateSource et manifest vers les chemins des fichiers que vous avez créés.

    Note

    La spécification d'un nom d'environnement est facultative lorsque vous spécifiez des noms de service et d'instance de service. La combinaison de ces deux éléments est unique dans votre AWS compte et AWS Proton peut déterminer l'environnement à partir de l'instance de service.

  5. Mettez à jour votre instance de service pour la redéployer. AWS Proton utilise les sorties de votre composant dans le modèle d'instance de service rendu, pour permettre à votre application d'utiliser le compartiment Amazon S3 approvisionné par le composant.