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. # Utilisation CI/CD de systèmes et de pipelines pour déployer avec AWS SAM AWS SAM aide les entreprises à créer des pipelines pour leurs CI/CD systèmes préférés, afin qu'elles puissent en tirer parti CI/CD avec un minimum d'efforts, tels que l'accélération de la fréquence des déploiements, la réduction des délais de modification et la réduction des erreurs de déploiement. AWS SAM simplifie CI/CD les tâches des applications sans serveur à l'aide de la création d'images de conteneur. Les images AWS SAM fournies incluent les outils AWS SAMCLI et les outils de génération pour un certain nombre d'environnements d' AWS Lambda exécution pris en charge. Cela facilite la création et le package d'applications sans serveur à l'aide du AWS SAMCLI. Ces images évitent également aux équipes de créer et de gérer leurs propres images pour les CI/CD systèmes. Pour plus d'informations sur la AWS SAM création d'images de conteneurs, consultez[Référentiels d'images pour AWS SAM](serverless-image-repositories.md). Plusieurs CI/CD systèmes prennent en charge la AWS SAM création d'images de conteneurs. CI/CD Le système à utiliser dépend de plusieurs facteurs. Il s'agit notamment de savoir si votre application utilise une seule ou plusieurs exécutions, ou si vous souhaitez créer votre application dans une image de conteneur ou directement sur une machine hôte, une machine virtuelle (VM) ou un hôte de matériel nu. AWS SAM fournit également un ensemble de modèles de pipeline par défaut pour plusieurs CI/CD systèmes qui encapsulent les meilleures pratiques AWS de déploiement. Ces modèles de pipeline par défaut utilisent des formats de configuration de JSON/YAML pipeline standard, et les meilleures pratiques intégrées permettent d'effectuer des déploiements multicomptes et multirégions, et de vérifier que les pipelines ne peuvent pas apporter de modifications involontaires à l'infrastructure. Vous disposez de deux options principales AWS SAM pour déployer vos applications sans serveur : 1) Modifier la configuration de votre pipeline existante pour utiliser des AWS SAMCLI commandes, ou 2) Générer un exemple de configuration de CI/CD pipeline que vous pouvez utiliser comme point de départ pour votre propre application. **Topics** + [Qu'est-ce qu'un pipeline ?](#deploying-whatis-pipeline) + [Comment AWS SAM télécharge les fichiers locaux lors du déploiement](deploy-upload-local-files.md) + [Générez un CI/CD pipeline de démarrage avec AWS SAM](serverless-generating-example-ci-cd.md) + [Comment personnaliser les pipelines de démarrage avec AWS SAM](serverless-customizing-starter-pipelines.md) + [Automatisez le déploiement de votre AWS SAM application](serverless-deploying-modify-pipeline.md) + [Comment utiliser l'authentification OIDC avec les pipelines AWS SAM](deploying-with-oidc.md) ## Qu'est-ce qu'un pipeline ? Un pipeline est une séquence automatisée d'étapes effectuées pour publier une nouvelle version d'une application. [Vous pouvez utiliser de nombreux CI/CD systèmes courants pour déployer vos applications, notamment [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) et Actions. AWS SAM GitHub](https://github.com/features/actions) Les modèles de pipeline incluent les meilleures pratiques de AWS déploiement pour faciliter les déploiements multicomptes et multirégions. AWS les environnements tels que le développement et la production existent généralement dans AWS des comptes différents. Cela permet aux équipes de développement de configurer des pipelines de déploiement sécurisés, sans apporter de modifications involontaires à l'infrastructure. Vous pouvez également fournir vos propres modèles de pipeline personnalisés pour aider à standardiser les pipelines au sein des équipes de développement. # Comment AWS SAM télécharge les fichiers locaux lors du déploiement Lorsque vous déployez votre application sur le AWS Cloud, AWS CloudFormation vos fichiers locaux doivent d'abord être téléchargés vers un AWS service accessible, tel qu'Amazon Simple Storage Service (Amazon S3). Cela inclut les fichiers locaux auxquels votre AWS SAM modèle fait référence. Pour répondre à cette exigence, AWS SAMCLI procédez comme suit lorsque vous utilisez la `sam package` commande `sam deploy` ou : 1. Télécharge automatiquement vos fichiers locaux vers un AWS service accessible. 1. Met automatiquement à jour votre modèle d'application pour faire référence au nouveau chemin de fichier. **Topics** + [Démo : utilisation de la CLI  AWS SAM pour charger le code d'une fonction Lambda](#deploy-upload-local-files-demo) + [Cas d’utilisation pris en charge](#deploy-upload-local-files-use) + [En savoir plus](#deploy-upload-local-files-learn) ## Démo : utilisation de la CLI  AWS SAM pour charger le code d'une fonction Lambda Dans cette démo, nous initialisons l'exemple d'application Hello World en utilisant un type de package .zip pour notre fonction Lambda. Nous utilisons la CLI  AWS SAM pour charger automatiquement notre code de fonction Lambda dans Amazon S3 et référencer son nouveau chemin dans notre modèle d'application. Tout d'abord, nous exécutons `sam init` pour initialiser notre application Hello World. ``` $ sam init ... Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example 2 - Multi-step workflow ... Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: y Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: demo ----------------------- Generating application: ----------------------- Name: demo Runtime: python3.9 Architectures: x86_64 Dependency Manager: pip Application Template: hello-world Output Directory: . Configuration file: demo/samconfig.toml ... ``` Le code de notre fonction Lambda est organisé dans le sous-répertoire `hello_world` de notre projet. ``` demo ├── README.md ├── hello_world │ ├── __init__.py │ ├── app.py │ └── requirements.txt ├── template.yaml └── tests ``` Dans notre AWS SAM modèle, nous référençons le chemin local vers notre code de fonction Lambda à l'aide de la `CodeUri` propriété. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Properties: CodeUri: hello_world/ Handler: app.lambda_handler Runtime: python3.9 ... ``` Ensuite, nous exécutons `sam build` pour créer notre application et préparer son déploiement. ``` $ sam build Starting Build use cache Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/7896875f-9bcc-4350-8adb-2c1d543627a1) is missing for (HelloWorldFunction), downloading dependencies and copying/building source Building codeuri: /Users/.../demo/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CleanUp Running PythonPipBuilder:ResolveDependencies Running PythonPipBuilder:CopySource Running PythonPipBuilder:CopySource Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml ... ``` Ensuite, nous exécutons `sam deploy --guided` pour déployer notre application. ``` $ sam deploy --guided Configuring SAM deploy ====================== Looking for config file [samconfig.toml] : Found Reading default arguments : Success Setting default arguments for 'sam deploy' ========================================= Stack Name [demo]: ENTER AWS Region [us-west-2]: ENTER #Shows you resources changes to be deployed and require a 'Y' to initiate deploy Confirm changes before deploy [Y/n]: n #SAM needs permission to be able to create roles to connect to the resources in your template Allow SAM CLI IAM role creation [Y/n]: ENTER #Preserves the state of previously provisioned resources when an operation fails Disable rollback [y/N]: ENTER HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y Save arguments to configuration file [Y/n]: ENTER SAM configuration file [samconfig.toml]: ENTER SAM configuration environment [default]: ENTER Looking for resources needed for deployment: ... Saved arguments to config file Running 'sam deploy' for future deployments will use the parameters saved above. The above parameters can be changed by modifying samconfig.toml Learn more about samconfig.toml syntax at https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html File with same data already exists at demo/da3c598813f1c2151579b73ad788cac8, skipping upload Deploying with following values =============================== Stack name : demo Region : us-west-2 Confirm changeset : False Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_IAM"] Parameter overrides : {} Signing Profiles : {} Initiating deployment ===================== ... Waiting for changeset to be created.. CloudFormation stack changeset ------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement ------------------------------------------------------------------------------------------------- + Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A oWorldPermissionProd n + Add HelloWorldFunctionRole AWS::IAM::Role N/A ... ------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680906292/1164338d-72e7-4593-a372-f2b3e67f542f 2023-04-07 12:24:58 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 5.0 seconds) ------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason ------------------------------------------------------------------------------------------------- CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole - CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation Initiated ... ------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack ------------------------------------------------------------------------------------------------- Outputs ------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/demo-HelloWorldFunctionRole-VQ4CU7UY7S2K Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://satnon55e9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:demo- HelloWorldFunction-G14inKTmSQvK ------------------------------------------------------------------------------------------------- Successfully created/updated stack - demo in us-west-2 ``` Lors du déploiement, la CLI  AWS SAM charge automatiquement notre code de fonction Lambda dans Amazon S3 et met à jour notre modèle. Notre modèle modifié dans la CloudFormation console reflète le chemin du compartiment Amazon S3. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: s3://aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr/demo/da3c598813f1c2151579b73ad788cac8 Handler: app.lambda_handler ... ``` ## Cas d’utilisation pris en charge Ils AWS SAMCLI peuvent automatiquement faciliter ce processus pour un certain nombre de types de fichiers, de types de CloudFormation ressources et de CloudFormation macros. ### Types de fichiers Les fichiers d'application et les images Docker sont pris en charge. ### CloudFormation types de ressources Vous trouverez ci-dessous une liste des types de ressources pris en charge et de leurs propriétés : | Ressource | Propriétés | | --- | --- | | AWS::ApiGateway::RestApi | BodyS3Location | | AWS::ApiGatewayV2::Api | BodyS3Location | | AWS::AppSync:FunctionConfiguration | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::AppSync::GraphQLSchema | DefinitionS3Location | | AWS::AppSync::Resolver | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::CloudFormation::ModuleVersion | ModulePackage | | AWS::CloudFormation::ResourceVersion | SchemaHandlerPackage | | AWS::ECR::Repository | RepositoryName | | AWS::ElasticBeanstalk::ApplicationVersion | SourceBundle | | AWS::Glue::Job | Command.ScriptLocation | | AWS::Lambda::Function | `Code` `Code.ImageUri` | | AWS::Lambda::LayerVersion | Content | | AWS::Serverless::Api | DefinitionUri | | AWS::Serverless::Function | `CodeUri` `ImageUri` | | AWS::Serverless::GraphQLApi | `SchemaUri` `Function.CodeUri` `Resolver.CodeUri` | | AWS::Serverless::HttpApi | DefinitionUri | | AWS::Serverless::LayerVersion | ContentUri | | AWS::Serverless::StateMachine | DefinitionUri | | AWS::StepFunctions::StateMachine | DefinitionS3Location | ### CloudFormation macros Les fichiers référencés à l'aide de la macro `AWS::Include` transform sont pris en charge. ## En savoir plus Pour en savoir plus sur la `AWS::Include` transformation, voir [ AWS::Include transformation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html) dans le *guide de AWS CloudFormation l'utilisateur*. Pour voir un exemple d'utilisation de la `AWS::Include` transformation dans un AWS SAM modèle, consultez le modèle [API Gateway HTTP API to SQS](https://serverlessland.com/patterns/apigw-sqs) sur *Serverless Land*. # Générez un CI/CD pipeline de démarrage avec AWS SAM Lorsque vous êtes prêt à automatiser le déploiement, vous pouvez utiliser l'un des modèles AWS SAM de pipeline de démarrage pour générer un pipeline de déploiement pour le CI/CD système que vous choisissez d'utiliser. Votre pipeline de déploiement est ce que vous configurez et utilisez pour automatiser le déploiement de votre application sans serveur. Un modèle de pipeline de démarrage est préconfiguré pour vous aider à configurer rapidement votre pipeline de déploiement pour votre application sans serveur. Avec un modèle de pipeline de démarrage, vous pouvez générer des pipelines en quelques minutes à l'aide de la [sam pipeline init](sam-cli-command-reference-sam-pipeline-init.md) commande. Les modèles de pipeline de démarrage utilisent la JSON/YAML syntaxe familière du CI/CD système et intègrent les meilleures pratiques, telles que la gestion des artefacts sur plusieurs comptes et régions, et l'utilisation du minimum d'autorisations requises pour déployer l'application. [Actuellement, la AWS SAM CLI prend en charge la génération de configurations de CI/CD pipeline de démarrage pour les [AWS CodePipeline](https://aws.amazon.com/codepipeline)pipelines [Jenkins](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/), [GitHub Actions](https://github.com/features/actions) et Bitbucket.](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) Voici les tâches de haut niveau que vous devez effectuer pour générer une configuration de pipeline de démarrage : 1. **Création de ressources d'infrastructure** : votre pipeline nécessite certaines AWS ressources, par exemple l'utilisateur IAM et les rôles dotés des autorisations nécessaires, un compartiment Amazon S3 et éventuellement un référentiel Amazon ECR. 1. **Connectez votre dépôt Git à votre CI/CD système** : votre CI/CD système doit savoir quel dépôt Git déclenchera l'exécution du pipeline. Notez que cette étape peut ne pas être nécessaire, selon la combinaison du référentiel Git et CI/CD du système que vous utilisez. 1. **Générez une configuration de pipeline** : cette étape génère une configuration de pipeline de démarrage qui inclut deux étapes de déploiement. 1. **Validez la configuration de votre pipeline dans votre dépôt Git** : cette étape est nécessaire pour s'assurer que votre CI/CD système est au courant de la configuration de votre pipeline et qu'elle sera exécutée lorsque les modifications seront validées. Après avoir généré la configuration du pipeline de démarrage et l’avoir associée au référentiel Git, le pipeline se déclenche pour s’exécuter automatiquement chaque fois que quelqu’un associe une modification de code au référentiel. L’ordre de ces étapes, ainsi que les détails de chaque étape, varient en fonction du système CI/CD : + Si vous utilisez AWS CodePipeline, consultez[Génération d'un pipeline de démarrage pour AWS CodePipeline in AWS SAM](serverless-generating-example-ci-cd-codepipeline.md). + Si vous utilisez Jenkins, GitLab CI/CD, GitHub Actions ou Bitbucket Pipelines, consultez. [AWS SAM À utiliser pour générer des pipelines de démarrage pour Jenkins, GitLab CI/CD, GitHub Actions, Bitbucket Pipelines](serverless-generating-example-ci-cd-others.md) # Génération d'un pipeline de démarrage pour AWS CodePipeline in AWS SAM Pour générer une configuration de pipeline de démarrage pour AWS CodePipeline, effectuez les tâches suivantes dans cet ordre : 1. Créer des ressources d’infrastructure 1. Générer la configuration du pipeline 1. Associer la configuration du pipeline au référentiel Git 1. Connectez votre dépôt Git à votre CI/CD système **Note** La procédure suivante utilise deux commandes de la CLI  AWS SAM, `sam pipeline bootstrap` et `sam pipeline init`. La raison pour laquelle il existe deux commandes est de gérer le cas d'utilisation où les administrateurs (c'est-à-dire les utilisateurs qui ont besoin d'une autorisation pour configurer des AWS ressources d'infrastructure telles que les utilisateurs et les rôles IAM) ont plus d'autorisations que les développeurs (c'est-à-dire les utilisateurs qui ont juste besoin d'une autorisation pour configurer des pipelines individuels, mais pas les AWS ressources d'infrastructure requises). ## Étape 1 : créer des ressources d’infrastructure Les pipelines utilisés AWS SAM nécessitent certaines AWS ressources, comme un utilisateur IAM et des rôles dotés des autorisations nécessaires, un compartiment Amazon S3 et éventuellement un référentiel Amazon ECR. Vous devez disposer d’un ensemble de ressources d’infrastructure pour chaque étape de déploiement du pipeline. Vous pouvez exécuter la commande suivante pour vous aider avec cette configuration : ``` sam pipeline bootstrap ``` **Note** Exécutez la commande précédente pour chaque étape de déploiement du pipeline. ## Étape 2 : générer la configuration du pipeline Pour générer la configuration du pipeline, exécutez la commande suivante : ``` sam pipeline init ``` ## Étape 3 : associer la configuration du pipeline au référentiel Git Cette étape est nécessaire pour s'assurer que votre CI/CD système connaît la configuration de votre pipeline et qu'elle sera exécutée lorsque les modifications seront validées. ## Étape 4 : Connectez votre dépôt Git à votre CI/CD système Car AWS CodePipeline vous pouvez désormais créer la connexion en exécutant la commande suivante : ``` sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --region ``` Si vous utilisez GitHub Bitbucket, après avoir exécuté la **sam deploy** commande précédemment, terminez la connexion en suivant les étapes décrites dans la section Pour établir **une connexion trouvée dans la rubrique Mettre à jour une connexion** [en attente](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-update.html) dans le *guide de l'utilisateur de la console Developer Tools*. En outre, stockez une copie `CodeStarConnectionArn` de la sortie de la **sam deploy** commande, car vous en aurez besoin si vous souhaitez l'utiliser AWS CodePipeline avec une autre branche que`main`. ## Configuration d’autres branches Par défaut, AWS CodePipeline utilise la `main` branche avec AWS SAM. Si vous voulez utiliser une branche autre que `main`, vous devez exécuter à nouveau la commande **sam deploy**. Notez que selon le référentiel Git que vous utilisez, il se peut que vous deviez aussi fournir le `CodeStarConnectionArn` : ``` # For GitHub and Bitbucket sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch= CodeStarConnectionArn=" # For AWS CodeCommit sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch=" ``` ## En savoir plus Pour un exemple pratique de configuration d'un CI/CD pipeline, voir [CI/CD with AWS CodePipeline](https://catalog.workshops.aws/complete-aws-sam/en-US/module-4-cicd) dans *The Complete AWS SAM * Workshop. # AWS SAM À utiliser pour générer des pipelines de démarrage pour Jenkins, GitLab CI/CD, GitHub Actions, Bitbucket Pipelines Pour générer une configuration de pipeline de démarrage pour les pipelines Jenkins, GitLab CI/CD, GitHub Actions ou Bitbucket, effectuez les tâches suivantes dans cet ordre : 1. Créer des ressources d’infrastructure 1. Connectez votre dépôt Git à votre CI/CD système 1. Créer des objets d’identification 1. Générer la configuration du pipeline 1. Associer la configuration du pipeline au référentiel Git **Note** La procédure suivante utilise deux commandes de la CLI  AWS SAM, `sam pipeline bootstrap` et `sam pipeline init`. La raison pour laquelle il existe deux commandes est de gérer le cas d'utilisation où les administrateurs (c'est-à-dire les utilisateurs qui ont besoin d'une autorisation pour configurer des AWS ressources d'infrastructure telles que les utilisateurs et les rôles IAM) ont plus d'autorisations que les développeurs (c'est-à-dire les utilisateurs qui ont juste besoin d'une autorisation pour configurer des pipelines individuels, mais pas les AWS ressources d'infrastructure requises). ## Étape 1 : créer des ressources d’infrastructure Les pipelines utilisés AWS SAM nécessitent certaines AWS ressources, comme un utilisateur IAM et des rôles dotés des autorisations nécessaires, un compartiment Amazon S3 et éventuellement un référentiel Amazon ECR. Vous devez disposer d’un ensemble de ressources d’infrastructure pour chaque étape de déploiement du pipeline. Vous pouvez exécuter la commande suivante pour vous aider avec cette configuration : ``` sam pipeline bootstrap ``` **Note** Exécutez la commande précédente pour chaque étape de déploiement du pipeline. Vous devez saisir les AWS informations d'identification (identifiant de clé et clé secrète) des utilisateurs du pipeline pour chaque étape de déploiement de votre pipeline, car elles sont nécessaires pour les étapes suivantes. ## Étape 2 : Connectez votre dépôt Git à votre CI/CD système La connexion de votre dépôt Git à votre CI/CD système est nécessaire pour que le CI/CD système puisse accéder au code source de votre application pour les builds et les déploiements. **Note** Vous pouvez ignorer cette étape si vous utilisez l’une des combinaisons suivantes, car la connexion est effectuée automatiquement : GitHub Actions avec le GitHub référentiel GitLab CI/CD avec dépôt GitLab Bitbucket Pipelines avec un référentiel Bitbucket Pour connecter votre dépôt Git à votre CI/CD système, effectuez l'une des opérations suivantes : + Si vous utilisez Jenkins, consultez « Ajout d’une source de branche » dans la section [Documentation Jenkins](https://www.jenkins.io/doc/book/pipeline/multibranch/). + Si vous utilisez GitLab CI/CD et un dépôt Git autre que celui-ci GitLab, consultez la [GitLabdocumentation relative](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/) à la « connexion à un dépôt externe ». ## Étape 3 : créer des objets des informations d’identification Chaque CI/CD système dispose de sa propre méthode de gestion des informations d'identification nécessaires pour accéder à votre dépôt Git. CI/CD Pour créer les objets des informations d’identification nécessaires, effectuez l’une des opérations suivantes : + Si vous utilisez Jenkins, créez une seule « information d’identification » qui stocke à la fois l’identifiant de la clé et la clé secrète. Suivez les instructions du blog [Création d’un pipeline Jenkins avec AWS SAM](https://aws.amazon.com/blogs/compute/building-a-jenkins-pipeline-with-aws-sam/), dans la section **Configurer Jenkins**. Vous aurez besoin de l’« identifiant des informations d’identification » pour l’étape suivante. + Si vous utilisez le GitLab CI/CD, créez deux « variables protégées », une pour chaque identifiant de clé et une clé secrète. Suivez les instructions de la [GitLab documentation](https://docs.gitlab.com/ee/ci/variables/). Vous aurez besoin de deux « clés variables » pour l'étape suivante. + Si vous utilisez GitHub Actions, créez deux « secrets chiffrés », un pour chaque clé et une pour chaque clé secrète. Suivez les instructions de la [GitHubdocumentation](https://docs.github.com/en/actions/reference/encrypted-secrets). Vous aurez besoin de deux « noms secrets » pour l'étape suivante. + Si vous utilisez Bitbucket Pipelines, créez deux « variables sécurisées », une pour chaque identifiant de clé et clé secrète. Suivez les instructions de la section [Variables et secrets ](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets). Vous aurez besoin de deux « noms secrets » pour l’étape suivante. ## Étape 4 : générer la configuration du pipeline Pour générer la configuration du pipeline, exécutez la commande suivante : Vous devez entrer l’objet des informations d’identification que vous avez créé à l’étape précédente : ``` sam pipeline init ``` ## Étape 5 : associer la configuration du pipeline au référentiel Git Cette étape est nécessaire pour s'assurer que votre CI/CD système connaît la configuration de votre pipeline et qu'elle sera exécutée lorsque les modifications seront validées. ## En savoir plus Pour un exemple pratique de configuration d'un CI/CD pipeline en utilisantGitHub Actions, voir [CI/CD with GitHub](https://s12d.com/sam-ws-en-gh) dans *The Complete AWS SAM * Workshop. # Comment personnaliser les pipelines de démarrage avec AWS SAM En tant qu' CI/CD administrateur, vous souhaiterez peut-être personnaliser un modèle de pipeline de démarrage, ainsi que les instructions guidées associées, que les développeurs de votre organisation peuvent utiliser pour créer des configurations de pipeline. La CLI  AWS SAM utilise des modèles Cookiecutter lors de la création des modèles de démarrage. Pour en savoir plus sur les modèles cookie cutter, consultez [Cookiecutter](https://cookiecutter.readthedocs.io/en/latest/README.html). Vous pouvez également personnaliser les invites que la CLI  AWS SAM affiche aux utilisateurs lors de la création de configurations de pipeline à l'aide de la commande `sam pipeline init`. Pour personnaliser les invites des utilisateurs, procédez comme suit : 1. **Créez un fichier `questions.json`** – Le fichier `questions.json` doit être à la racine du référentiel du projet. Il s'agit du même répertoire que pour le fichier `cookiecutter.json`. Pour afficher le schéma du fichier `questions.json`, consultez [questions.json.schema](https://github.com/aws/aws-sam-cli/blob/2b831b29f76ac9c4e0cbcbd68b37f8f664e136d8/samcli/lib/pipeline/init/questions.json.schema). Pour afficher un exemple de fichier `questions.json`, consultez [questions.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/questions.json). 1. **Mapper les clés de questions avec les noms des coupeurs de cookies** – Chaque objet du fichier `questions.json` nécessite une clé qui correspond à un nom dans le modèle Cookiecutter. Cette correspondance de clé est la façon dont la CLI  AWS SAM met en correspondance les réponses des utilisateurs au modèle de cookie cutter. Pour voir des exemples de correspondance de cette clé, consultez la section [Exemples de fichier](#serverless-customizing-starter-pipelines-example-files) plus loin dans cette rubrique. 1. **Créez un fichier `metadata.json`** – Déclarez le nombre d'étapes que le pipeline aura dans le fichier `metadata.json`. Le nombre d'étapes indique à la commande `sam pipeline init` le nombre d'étapes nécessaire pour fournir des informations ou, dans le cas de l'option `--bootstrap`, le nombre d'étapes pour lesquelles créer des ressources d'infrastructure. Pour accéder à un exemple de fichier `metadata.json`qui déclare un pipeline à deux étapes, consultez [metadata.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/metadata.json). ## Exemples de projets Voici des exemples de projets, qui comprennent chacun un modèle Cookiecutter, un fichier `questions.json` et un fichier `metadata.json` : + Exemple de Jenkins : [Modèle de pipeline Jenkins en deux étapes](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/Jenkins/two-stage-pipeline-template) + CodePipeline exemple : [modèle de CodePipeline pipeline en deux étapes](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/AWS-CodePipeline/two-stage-pipeline-template) ## Exemples de fichier L'ensemble de fichiers suivant montre comment les questions dans le fichier `questions.json` sont associées aux entrées du fichier de modèle Cookiecutter. Notez que ces exemples sont des extraits de fichiers, non des fichiers complets. Pour voir des exemples de fichiers complets, consultez la section [Exemples de projets](#serverless-customizing-starter-pipelines-example-projects) plus loin dans cette rubrique. Exemple **`questions.json`** : ``` { "questions": [{ "key": "intro", "question": "\nThis template configures a pipeline that deploys a serverless application to a testing and a production stage.\n", "kind": "info" }, { "key": "pipeline_user_jenkins_credential_id", "question": "What is the Jenkins credential ID (via Jenkins plugin \"aws-credentials\") for pipeline user access key?", "isRequired": true }, { "key": "sam_template", "question": "What is the template file path?", "default": "template.yaml" }, { ... ``` Exemple **`cookiecutter.json`** : ``` { "outputDir": "aws-sam-pipeline", "pipeline_user_jenkins_credential_id": "", "sam_template": "", ... ``` Exemple **`Jenkinsfile`** : ``` pipeline { agent any environment { PIPELINE_USER_CREDENTIAL_ID = '{{cookiecutter.pipeline_user_jenkins_credential_id}}' SAM_TEMPLATE = '{{cookiecutter.sam_template}}' ... ``` # Automatisez le déploiement de votre AWS SAM application Dans AWS SAM, la manière dont vous automatisez le déploiement de votre AWS SAM application varie en fonction du CI/CD système que vous utilisez. C'est pourquoi les exemples présentés dans cette section vous montrent comment configurer différents CI/CD systèmes pour automatiser la création d'applications sans serveur dans une image de conteneur de AWS SAM génération. Ces images de conteneur de génération facilitent la création et le package d'applications sans serveur à l'aide du AWS SAMCLI. Les procédures de votre CI/CD pipeline existant pour déployer des applications sans serveur AWS SAM sont légèrement différentes selon le CI/CD système que vous utilisez. Les rubriques suivantes fournissent des exemples de configuration de votre CI/CD système pour créer des applications sans serveur dans une image de conteneur de AWS SAM génération : **Topics** + [Utilisation AWS CodePipeline pour déployer avec AWS SAM](deploying-using-codepipeline.md) + [Utilisation de Bitbucket Pipelines pour déployer avec AWS SAM](deploying-using-bitbucket.md) + [Utiliser Jenkins pour déployer avec AWS SAM](deploying-using-jenkins.md) + [Utilisation de GitLab CI/CD pour déployer avec AWS SAM](deploying-using-gitlab.md) + [Utiliser GitHub des actions pour déployer avec AWS SAM](deploying-using-github.md) # Utilisation AWS CodePipeline pour déployer avec AWS SAM Pour configurer votre [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)pipeline afin d'automatiser la création et le déploiement de votre AWS SAM application, votre CloudFormation modèle et votre `buildspec.yml` fichier doivent contenir les lignes suivantes : 1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`. 1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI  AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires). Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`. **CloudFormation extrait de modèle :** ``` CodeBuildProject: Type: AWS::CodeBuild::Project Properties: Environment: ComputeType: BUILD_GENERAL1_SMALL Image: public.ecr.aws/sam/build-nodejs20.x Type: LINUX_CONTAINER ... ``` **`buildspec.yml` extrait :** ``` version: 0.2 phases: build: commands: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Pour obtenir la liste des images de conteneur de création Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md). # Utilisation de Bitbucket Pipelines pour déployer avec AWS SAM Pour configurer votre [pipeline Bitbucket](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) afin d'automatiser la création et le déploiement de votre AWS SAM application, votre `bitbucket-pipelines.yml` fichier doit contenir les lignes suivantes : 1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`. 1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI  AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires). Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x pipelines: branches: main: # branch name - step: name: Build and Package script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md). # Utiliser Jenkins pour déployer avec AWS SAM Pour configurer votre pipeline [Jenkins](https://www.jenkins.io/) afin d'automatiser la création et le déploiement de votre AWS SAM application, vous `Jenkinsfile` devez contenir des lignes qui effectuent les opérations suivantes : 1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`. 1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI  AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires). Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`. ``` pipeline { agent { docker { image 'public.ecr.aws/sam/build-nodejs20.x' } } stages { stage('build') { steps { sh 'sam build' sh 'sam deploy --no-confirm-changeset --no-fail-on-empty-changeset' } } } } ``` Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md). # Utilisation de GitLab CI/CD pour déployer avec AWS SAM Pour configurer votre [GitLab](https://about.gitlab.com)pipeline afin d'automatiser la création et le déploiement de votre AWS SAM application, votre `gitlab-ci.yml` fichier doit contenir les lignes suivantes : 1. Référencer une image de conteneur de création avec l’exécution nécessaire à partir des images disponibles. L’exemple suivant utilise l’image de conteneur de création `public.ecr.aws/sam/build-nodejs20.x`. 1. Configurez les étapes du pipeline pour exécuter les commandes d'interface de ligne de AWS SAM commande (CLI) nécessaires. L'exemple suivant exécute deux commandes de la CLI  AWS SAM : **sam build** et **sam deploy** (avec les options nécessaires). Cet exemple suppose que vous avez déclaré toutes les fonctions et couches de votre fichier AWS SAM modèle avec`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x deploy: script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md). # Utiliser GitHub des actions pour déployer avec AWS SAM Pour configurer votre [GitHub](https://github.com/)pipeline afin d'automatiser la création et le déploiement de votre AWS SAM application, vous devez d'abord installer l'interface de ligne de AWS SAM commande (CLI) sur votre hôte. Vous pouvez utiliser [GitHub les actions](https://github.com/features/actions) dans votre GitHub flux de travail pour faciliter cette configuration. L'exemple de GitHub flux de travail suivant configure un hôte Ubuntu à l'aide d'une série d' GitHubactions, puis exécute des AWS SAMCLI commandes pour créer et déployer une AWS SAM application : ``` on: push: branches: - main jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-python@v3 - uses: aws-actions/setup-sam@v2 - uses: aws-actions/configure-aws-credentials@v1 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: us-east-2 - run: sam build --use-container - run: sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Pour obtenir la liste des images de conteneur de construction Amazon Elastic Container Registry (Amazon ECR) disponibles pour différentes exécutions, consultez [Référentiels d'images pour AWS SAM](serverless-image-repositories.md). # Comment utiliser l'authentification OIDC avec les pipelines AWS SAM AWS Serverless Application Model (AWS SAM) prend en charge l'authentification utilisateur OpenID Connect (OIDC) pour Bitbucket, GitHub Actions, ainsi que l'intégration GitLab continue et la livraison continue (comptes CI/CD) platforms. With this support, you can use authorized CI/CD utilisateurs) de l'une de ces plateformes pour gérer vos pipelines d'applications sans serveur. Dans le cas contraire, vous devrez créer et gérer plusieurs utilisateurs Gestion des identités et des accès AWS (IAM) pour contrôler l'accès aux AWS SAM pipelines. ## Configuration de l'OIDC avec un pipeline AWS SAM Au cours du processus de `sam pipeline bootstrap` configuration, procédez comme suit pour configurer OIDC avec votre AWS SAM pipeline. 1. Lorsque vous êtes invité à choisir un fournisseur d'identité, sélectionnez **OIDC**. 1. Ensuite, sélectionnez un fournisseur OIDC pris en charge. 1. Saisissez l'URL du fournisseur OIDC, en commençant par **https://**. **Note** AWS SAM fait référence à cette URL lorsqu'elle génère le type de `AWS::IAM::OIDCProvider` ressource. 1. Suivez ensuite les instructions et entrez les informations de CI/CD plate-forme nécessaires pour accéder à la plate-forme sélectionnée. Ces informations varient selon la plateforme et peuvent inclure : + un ID client OIDC ; + le nom du référentiel ou l'identifiant universel unique (UUID) du code ; + le nom de groupe ou d'organisation associé au référentiel ; + GitHub organisation à laquelle appartient le référentiel de code. + GitHub nom du référentiel. + la branche à partir de laquelle les déploiements seront effectués. 1. AWS SAM affiche un résumé de la configuration OIDC saisie. Saisissez le numéro d'un paramètre pour le modifier, ou appuyez sur Enter pour continuer. 1. Lorsque vous êtes invité à confirmer la création des ressources nécessaires pour prendre en charge la connexion OIDC saisie, appuyez sur Y pour continuer. AWS SAM génère une `AWS::IAM::OIDCProvider` AWS CloudFormation ressource avec la configuration fournie qui assume le rôle d'exécution du pipeline. Pour en savoir plus sur ce type de CloudFormation ressource, consultez [AWS : :IAM : : OIDCProvider](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-oidcprovider.html) dans le guide de l'*AWS CloudFormation utilisateur*. **Note** Si la ressource du fournisseur d'identité (IdP) existe déjà dans votre répertoire Compte AWS, AWS SAM référencez-la au lieu de créer une nouvelle ressource. ## Exemple Voici un exemple de configuration d'OIDC avec un AWS SAM pipeline. ``` Select a permissions provider: 1 - IAM (default) 2 - OpenID Connect (OIDC) Choice (1, 2): 2 Select an OIDC provider: 1 - GitHub Actions 2 - GitLab 3 - Bitbucket Choice (1, 2, 3): 1 Enter the URL of the OIDC provider [https://token.actions.githubusercontent.com]: Enter the OIDC client ID (sometimes called audience) [sts.amazonaws.com]: Enter the GitHub organization that the code repository belongs to. If there is no organization enter your username instead: my-org Enter GitHub repository name: testing Enter the name of the branch that deployments will occur from [main]: [3] Reference application build resources Enter the pipeline execution role ARN if you have previously created one, or we will create one for you []: Enter the CloudFormation execution role ARN if you have previously created one, or we will create one for you []: Please enter the artifact bucket ARN for your Lambda function. If you do not have a bucket, we will create one for you []: Does your application contain any IMAGE type Lambda functions? [y/N]: [4] Summary Below is the summary of the answers: 1 - Account: 123456 2 - Stage configuration name: dev 3 - Region: us-east-1 4 - OIDC identity provider URL: https://token.actions.githubusercontent.com 5 - OIDC client ID: sts.amazonaws.com 6 - GitHub organization: my-org 7 - GitHub repository: testing 8 - Deployment branch: main 9 - Pipeline execution role: [to be created] 10 - CloudFormation execution role: [to be created] 11 - Artifacts bucket: [to be created] 12 - ECR image repository: [skipped] Press enter to confirm the values above, or select an item to edit the value: This will create the following required resources for the 'dev' configuration: - IAM OIDC Identity Provider - Pipeline execution role - CloudFormation execution role - Artifact bucket Should we proceed with the creation? [y/N]: ``` ## En savoir plus Pour plus d'informations sur l'utilisation de l'OIDC avec un AWS SAM pipeline, consultez[sam pipeline bootstrap](sam-cli-command-reference-sam-pipeline-bootstrap.md).