Public ciblé Authentification par des identités Gestion des accès à l’aide de politiques Gérer le rôle CodePipeline de service

Gestion des identités et des accès pour AWS CodePipeline

AWS Identity and Access Management (IAM) est un outil Service AWS qui permet à un administrateur de contrôler en toute sécurité l'accès aux AWS ressources. Les administrateurs IAM contrôlent qui peut être authentifié (connecté) et autorisé (autorisé) à utiliser CodePipeline les ressources. IAM est un Service AWS outil que vous pouvez utiliser sans frais supplémentaires.

Rubriques

Public ciblé

La façon dont vous utilisez AWS Identity and Access Management (IAM) varie en fonction du travail que vous effectuez. CodePipeline

Utilisateur du service : si vous utilisez le CodePipeline service pour effectuer votre travail, votre administrateur vous fournit les informations d'identification et les autorisations dont vous avez besoin. Au fur et à mesure que vous utilisez de nouvelles CodePipeline fonctionnalités pour effectuer votre travail, vous aurez peut-être besoin d'autorisations supplémentaires. En comprenant bien la gestion des accès, vous saurez demander les autorisations appropriées à votre administrateur. Si vous ne pouvez pas accéder à une fonctionnalité dans CodePipeline, consultezRésolution des problèmes d’identité et d’accès avec AWS CodePipeline.

Administrateur du service — Si vous êtes responsable des CodePipeline ressources de votre entreprise, vous avez probablement un accès complet à CodePipeline. C'est à vous de déterminer les CodePipeline fonctionnalités et les ressources auxquelles les utilisateurs de votre service doivent accéder. Vous devez ensuite soumettre les demandes à votre administrateur IAM pour modifier les autorisations des utilisateurs de votre service. Consultez les informations sur cette page pour comprendre les concepts de base d’IAM. Pour en savoir plus sur la manière dont votre entreprise peut utiliser IAM avec CodePipeline, voirComment AWS CodePipeline fonctionne avec IAM.

Administrateur IAM — Si vous êtes administrateur IAM, vous souhaiterez peut-être en savoir plus sur la manière dont vous pouvez rédiger des politiques pour gérer l'accès à. CodePipeline Pour consulter des exemples de politiques CodePipeline basées sur l'identité que vous pouvez utiliser dans IAM, consultez. Exemples de politiques basées sur l’identité AWS CodePipeline

Authentification par des identités

L'authentification est la façon dont vous vous connectez à AWS l'aide de vos informations d'identification. Vous devez être authentifié (connecté à AWS) en tant qu'utilisateur IAM ou en assumant un rôle IAM. Utilisateur racine d'un compte AWS

Vous pouvez vous connecter en AWS tant qu'identité fédérée en utilisant les informations d'identification fournies par le biais d'une source d'identité. AWS IAM Identity Center Les utilisateurs (IAM Identity Center), l'authentification unique de votre entreprise et vos informations d'identification Google ou Facebook sont des exemples d'identités fédérées. Lorsque vous vous connectez avec une identité fédérée, votre administrateur aura précédemment configuré une fédération d’identités avec des rôles IAM. Lorsque vous accédez à AWS l'aide de la fédération, vous assumez indirectement un rôle.

Selon le type d'utilisateur que vous êtes, vous pouvez vous connecter au portail AWS Management Console ou au portail AWS d'accès. Pour plus d'informations sur la connexion à AWS, consultez Comment vous connecter à votre compte Compte AWS dans le guide de Connexion à AWS l'utilisateur.

Si vous y accédez AWS par programmation, AWS fournit un kit de développement logiciel (SDK) et une interface de ligne de commande (CLI) pour signer cryptographiquement vos demandes à l'aide de vos informations d'identification. Si vous n'utilisez pas d' AWS outils, vous devez signer vous-même les demandes. Pour plus d'informations sur l'utilisation de la méthode recommandée pour signer vous-même les demandes, consultez la section Signature des demandes AWS d'API dans le guide de l'utilisateur IAM.

Quelle que soit la méthode d’authentification que vous utilisez, vous devrez peut-être fournir des informations de sécurité supplémentaires. Par exemple, il vous AWS recommande d'utiliser l'authentification multifactorielle (MFA) pour renforcer la sécurité de votre compte. Pour en savoir plus, consultez Authentification multifactorielle dans le Guide de l’utilisateur AWS IAM Identity Center et Utilisation de l’authentification multifactorielle (MFA) dans l’interface AWS dans le Guide de l’utilisateur IAM.

Utilisateur racine d'un compte AWS

Lorsque vous créez un Compte AWS, vous commencez par une identité de connexion unique qui donne un accès complet à toutes Services AWS les ressources du compte. Cette identité est appelée utilisateur Compte AWS root et est accessible en vous connectant avec l'adresse e-mail et le mot de passe que vous avez utilisés pour créer le compte. Il est vivement recommandé de ne pas utiliser l’utilisateur racine pour vos tâches quotidiennes. Protégez vos informations d’identification d’utilisateur racine et utilisez-les pour effectuer les tâches que seul l’utilisateur racine peut effectuer. Pour obtenir la liste complète des tâches qui vous imposent de vous connecter en tant qu’utilisateur racine, consultez Tâches nécessitant les informations d’identification de l’utilisateur racine dans le Guide de l’utilisateur IAM.

Utilisateurs et groupes IAM

Un utilisateur IAM est une identité au sein de vous Compte AWS qui possède des autorisations spécifiques pour une seule personne ou une seule application. Dans la mesure du possible, nous vous recommandons de vous appuyer sur des informations d’identification temporaires plutôt que de créer des utilisateurs IAM ayant des informations d’identification à long terme tels que les clés d’accès. Toutefois, si certains cas d’utilisation spécifiques nécessitent des informations d’identification à long terme avec les utilisateurs IAM, nous vous recommandons de faire pivoter les clés d’accès. Pour plus d’informations, consultez Rotation régulière des clés d’accès pour les cas d’utilisation nécessitant des informations d’identification dans le Guide de l’utilisateur IAM.

Un groupe IAM est une identité qui concerne un ensemble d’utilisateurs IAM. Vous ne pouvez pas vous connecter en tant que groupe. Vous pouvez utiliser les groupes pour spécifier des autorisations pour plusieurs utilisateurs à la fois. Les groupes permettent de gérer plus facilement les autorisations pour de grands ensembles d’utilisateurs. Par exemple, vous pouvez avoir un groupe nommé IAMAdmins et accorder à ce groupe les autorisations d’administrer des ressources IAM.

Les utilisateurs sont différents des rôles. Un utilisateur est associé de manière unique à une personne ou une application, alors qu’un rôle est conçu pour être endossé par tout utilisateur qui en a besoin. Les utilisateurs disposent d’informations d’identification permanentes, mais les rôles fournissent des informations d’identification temporaires. Pour en savoir plus, consultez Quand créer un utilisateur IAM (au lieu d’un rôle) dans le Guide de l’utilisateur IAM.

Rôles IAM

Un rôle IAM est une identité au sein de vous Compte AWS dotée d'autorisations spécifiques. Le concept ressemble à celui d’utilisateur IAM, mais le rôle IAM n’est pas associé à une personne en particulier. Vous pouvez assumer temporairement un rôle IAM dans le en AWS Management Console changeant de rôle. Vous pouvez assumer un rôle en appelant une opération d' AWS API AWS CLI ou en utilisant une URL personnalisée. Pour plus d’informations sur les méthodes d’utilisation des rôles, consultez Utilisation de rôles IAM dans le Guide de l’utilisateur IAM.

Les rôles IAM avec des informations d’identification temporaires sont utiles dans les cas suivants :

Accès utilisateur fédéré – Pour attribuer des autorisations à une identité fédérée, vous créez un rôle et définissez des autorisations pour le rôle. Quand une identité externe s’authentifie, l’identité est associée au rôle et reçoit les autorisations qui sont définies par celui-ci. Pour obtenir des informations sur les rôles pour la fédération, consultez Création d’un rôle pour un fournisseur d’identité tiers (fédération) dans le Guide de l’utilisateur IAM. Si vous utilisez IAM Identity Center, vous configurez un jeu d’autorisations. IAM Identity Center met en corrélation le jeu d’autorisations avec un rôle dans IAM afin de contrôler à quoi vos identités peuvent accéder après leur authentification. Pour plus d’informations sur les jeux d’autorisations, consultez la rubrique Jeux d’autorisations dans le Guide de l’utilisateur AWS IAM Identity Center .
Autorisations d’utilisateur IAM temporaires : un rôle ou un utilisateur IAM peut endosser un rôle IAM pour profiter temporairement d’autorisations différentes pour une tâche spécifique.
Accès intercompte : vous pouvez utiliser un rôle IAM pour permettre à un utilisateur (principal de confiance) d’un compte différent d’accéder aux ressources de votre compte. Les rôles constituent le principal moyen d’accorder l’accès intercompte. Toutefois, dans certains Services AWS cas, vous pouvez associer une politique directement à une ressource (au lieu d'utiliser un rôle comme proxy). Pour en savoir plus sur la différence entre les rôles et les politiques basées sur les ressources pour l’accès intercompte, consultez Différence entre les rôles IAM et les politiques basées sur les ressources dans le Guide de l’utilisateur IAM.
Accès multiservices — Certains Services AWS utilisent des fonctionnalités dans d'autres Services AWS. Par exemple, lorsque vous effectuez un appel dans un service, il est courant que ce service exécute des applications dans Amazon EC2 ou stocke des objets dans Amazon S3. Un service peut le faire en utilisant les autorisations d’appel du principal, un rôle de service ou un rôle lié au service.
- Sessions d'accès direct (FAS) : lorsque vous utilisez un utilisateur ou un rôle IAM pour effectuer des actions AWS, vous êtes considéré comme un mandant. Lorsque vous utilisez certains services, vous pouvez effectuer une action qui initie une autre action dans un autre service. FAS utilise les autorisations du principal appelant et Service AWS, associées Service AWS à la demande, pour adresser des demandes aux services en aval. Les demandes FAS ne sont effectuées que lorsqu'un service reçoit une demande qui nécessite des interactions avec d'autres personnes Services AWS ou des ressources pour être traitée. Dans ce cas, vous devez disposer d’autorisations nécessaires pour effectuer les deux actions. Pour plus de détails sur la politique relative à la transmission de demandes FAS, consultez Sessions de transmission d’accès.
- Rôle de service : il s’agit d’un rôle IAM attribué à un service afin de réaliser des actions en votre nom. Un administrateur IAM peut créer, modifier et supprimer une fonction du service à partir d’IAM. Pour plus d’informations, consultez Création d’un rôle pour la délégation d’autorisations à un Service AWS dans le Guide de l’utilisateur IAM.
- Rôle lié à un service — Un rôle lié à un service est un type de rôle de service lié à un. Service AWS Le service peut endosser le rôle afin d’effectuer une action en votre nom. Les rôles liés au service apparaissent dans votre Compte AWS fichier et appartiennent au service. Un administrateur IAM peut consulter, mais ne peut pas modifier, les autorisations concernant les rôles liés à un service.
Applications exécutées sur Amazon EC2 : vous pouvez utiliser un rôle IAM pour gérer les informations d'identification temporaires pour les applications qui s'exécutent sur une instance EC2 et qui envoient des demandes d'API. AWS CLI AWS Cette solution est préférable au stockage des clés d’accès au sein de l’instance EC2. Pour attribuer un AWS rôle à une instance EC2 et le mettre à la disposition de toutes ses applications, vous devez créer un profil d'instance attaché à l'instance. Un profil d’instance contient le rôle et permet aux programmes qui s’exécutent sur l’instance EC2 d’obtenir des informations d’identification temporaires. Pour plus d’informations, consultez Utilisation d’un rôle IAM pour accorder des autorisations à des applications s’exécutant sur des instances Amazon EC2 dans le Guide de l’utilisateur IAM.

Pour savoir dans quel cas utiliser des rôles ou des utilisateurs IAM, consultez Quand créer un rôle IAM (au lieu d’un utilisateur) dans le Guide de l’utilisateur IAM.

Gestion des accès à l’aide de politiques

Vous contrôlez l'accès en AWS créant des politiques et en les associant à AWS des identités ou à des ressources. Une politique est un objet AWS qui, lorsqu'il est associé à une identité ou à une ressource, définit leurs autorisations. AWS évalue ces politiques lorsqu'un principal (utilisateur, utilisateur root ou session de rôle) fait une demande. Les autorisations dans les politiques déterminent si la demande est autorisée ou refusée. La plupart des politiques sont stockées AWS sous forme de documents JSON. Pour plus d’informations sur la structure et le contenu des documents de politique JSON, consultez Vue d’ensemble des politiques JSON dans le Guide de l’utilisateur IAM.

Les administrateurs peuvent utiliser les politiques AWS JSON pour spécifier qui a accès à quoi. C’est-à-dire, quel principal peut effectuer des actions sur quelles ressources et dans quelles conditions.

Par défaut, les utilisateurs et les rôles ne disposent d’aucune autorisation. Pour octroyer aux utilisateurs des autorisations d’effectuer des actions sur les ressources dont ils ont besoin, un administrateur IAM peut créer des politiques IAM. L’administrateur peut ensuite ajouter les politiques IAM aux rôles et les utilisateurs peuvent assumer les rôles.

Les politiques IAM définissent les autorisations d’une action, quelle que soit la méthode que vous utilisez pour exécuter l’opération. Par exemple, supposons que vous disposiez d’une politique qui autorise l’action iam:GetRole. Un utilisateur appliquant cette politique peut obtenir des informations sur le rôle à partir de AWS Management Console AWS CLI, de ou de l' AWS API.

Politiques basées sur l’identité

Les politiques basées sur l’identité sont des documents de politique d’autorisations JSON que vous pouvez attacher à une identité telle qu’un utilisateur, un groupe d’utilisateurs ou un rôle IAM. Ces politiques contrôlent quel type d’actions des utilisateurs et des rôles peuvent exécuter, sur quelles ressources et dans quelles conditions. Pour découvrir comment créer une politique basée sur l’identité, consultez Création de politiques IAM dans le Guide de l’utilisateur IAM.

Les politiques basées sur l’identité peuvent être classées comme des politiques en ligne ou des politiques gérées. Les politiques en ligne sont intégrées directement à un utilisateur, groupe ou rôle. Les politiques gérées sont des politiques autonomes que vous pouvez associer à plusieurs utilisateurs, groupes et rôles au sein de votre Compte AWS. Les politiques gérées incluent les politiques AWS gérées et les politiques gérées par le client. Pour découvrir comment choisir entre une politique gérée et une politique en ligne, consultez Choix entre les politiques gérées et les politiques en ligne dans le Guide de l’utilisateur IAM.

politiques basées sur les ressources

Les politiques basées sur les ressources sont des documents de politique JSON que vous attachez à une ressource. Des politiques basées sur les ressources sont, par exemple, les politiques de confiance de rôle IAM et des politiques de compartiment. Dans les services qui sont compatibles avec les politiques basées sur les ressources, les administrateurs de service peuvent les utiliser pour contrôler l’accès à une ressource spécifique. Pour la ressource dans laquelle se trouve la politique, cette dernière définit quel type d’actions un principal spécifié peut effectuer sur cette ressource et dans quelles conditions. Vous devez spécifier un principal dans une politique basée sur les ressources. Les principaux peuvent inclure des comptes, des utilisateurs, des rôles, des utilisateurs fédérés ou. Services AWS

Les politiques basées sur les ressources sont des politiques en ligne situées dans ce service. Vous ne pouvez pas utiliser les politiques AWS gérées par IAM dans une stratégie basée sur les ressources.

Autres types de politique

AWS prend en charge d'autres types de politiques moins courants. Ces types de politiques peuvent définir le nombre maximum d’autorisations qui vous sont accordées par des types de politiques plus courants.

Limite d’autorisations : une limite d’autorisations est une fonctionnalité avancée dans laquelle vous définissez le nombre maximal d’autorisations qu’une politique basée sur l’identité peut accorder à une entité IAM (utilisateur ou rôle IAM). Vous pouvez définir une limite d’autorisations pour une entité. Les autorisations en résultant représentent la combinaison des politiques basées sur l’identité d’une entité et de ses limites d’autorisation. Les politiques basées sur les ressources qui spécifient l’utilisateur ou le rôle dans le champ Principal ne sont pas limitées par les limites d’autorisations. Un refus explicite dans l’une de ces politiques remplace l’autorisation. Pour plus d’informations sur les limites d’autorisations, consultez Limites d’autorisations pour des entités IAM dans le Guide de l’utilisateur IAM.
Politiques de contrôle des services (SCP) — Les SCP sont des politiques JSON qui spécifient les autorisations maximales pour une organisation ou une unité organisationnelle (UO) dans. AWS Organizations AWS Organizations est un service permettant de regrouper et de gérer de manière centralisée Comptes AWS les multiples propriétés de votre entreprise. Si vous activez toutes les fonctionnalités d’une organisation, vous pouvez appliquer les politiques de contrôle des services (SCP) à l’un ou à l’ensemble de vos comptes. Le SCP limite les autorisations pour les entités figurant dans les comptes des membres, y compris chacune Utilisateur racine d'un compte AWS d'entre elles. Pour plus d’informations sur les organisations et les SCP, consultez Fonctionnement des SCP dans le Guide de l’utilisateur AWS Organizations .
Politiques de séance : les politiques de séance sont des politiques avancées que vous utilisez en tant que paramètre lorsque vous créez par programmation une séance temporaire pour un rôle ou un utilisateur fédéré. Les autorisations de séance en résultant sont une combinaison des politiques basées sur l’identité de l’utilisateur ou du rôle et des politiques de séance. Les autorisations peuvent également provenir d’une politique basée sur les ressources. Un refus explicite dans l’une de ces politiques annule l’autorisation. Pour plus d’informations, consultez politiques de séance dans le Guide de l’utilisateur IAM.

Gérer le rôle CodePipeline de service

Le rôle de CodePipeline service est configuré avec une ou plusieurs politiques qui contrôlent l'accès aux AWS ressources utilisées par le pipeline. Vous souhaiterez peut-être associer d'autres politiques à ce rôle, modifier la politique attachée au rôle ou configurer des politiques pour d'autres rôles de service dans AWS. Vous pouvez également attacher une stratégie à un rôle lorsque vous configurez l'accès entre comptes à votre pipeline.

Important

Le fait de modifier une déclaration de stratégie ou d'associer une autre stratégie au rôle peut nuire au fonctionnement de vos pipelines. Assurez-vous de bien comprendre les implications avant de modifier le rôle de service de quelque CodePipeline manière que ce soit. Veillez à tester vos pipelines après avoir modifié le rôle de service.

Note

Dans la console, les rôles de service créés avant septembre 2018 sont créés avec le nom oneClick_AWS-CodePipeline-Service_ID-Number.

Les rôles de service créés après septembre 2018 utilisent le format de nom de rôle de service AWSCodePipelineServiceRole-Region-Pipeline_Name. Par exemple, pour un pipeline nommé MyFirstPipeline danseu-west-2, la console nomme le rôle et la politiqueAWSCodePipelineServiceRole-eu-west-2-MyFirstPipeline.

Suppression d'autorisations du rôle de service CodePipeline

Vous pouvez modifier la déclaration du rôle de service pour supprimer l'accès aux ressources que vous n'utilisez pas. Par exemple, si aucun de vos pipelines n'inclut Elastic Beanstalk, vous pouvez modifier la déclaration de politique afin de supprimer la section qui autorise l'accès aux ressources Elastic Beanstalk.

De même, si aucun de vos pipelines ne l'inclut CodeDeploy, vous pouvez modifier la déclaration de politique pour supprimer la section qui accorde l'accès aux CodeDeploy ressources :


    {
    "Action": [
        "codedeploy:CreateDeployment",
        "codedeploy:GetApplicationRevision",
        "codedeploy:GetDeployment",
        "codedeploy:GetDeploymentConfig",
        "codedeploy:RegisterApplicationRevision"
    ],
    "Resource": "*",
    "Effect": "Allow"
},

Ajout d'autorisations au rôle de service CodePipeline

Vous devez mettre à jour votre déclaration de politique de rôle de service avec des autorisations pour une déclaration de politique de rôle de service qui n'est Service AWS pas déjà incluse dans la déclaration de politique de rôle de service par défaut avant de pouvoir l'utiliser dans vos pipelines.

Cela est particulièrement important si le rôle de service que vous utilisez pour vos pipelines a été créé avant que le support ne soit ajouté CodePipeline à un Service AWS.

Le tableau suivant indique à quel moment le support a été ajouté pour les autres Services AWS.

Service AWS	CodePipeline date de support
AWS CloudFormation StackSets actions	30 décembre 2020
CodeCommit format d'artefact de sortie par clone complet	11 novembre 2020
CodeBuild constructions par lots	30 juillet 2020
AWS AppConfig	22 juin 2020
AWS Step Functions	27 mai 2020
AWS CodeStar Connexions	18 décembre 2019
L'action `CodeDeployToECS`	27 novembre 2018
Amazon ECR	27 novembre 2018
Service Catalog	16 octobre 2018
AWS Device Farm	19 juillet 2018
Amazon ECS	12 décembre 2017/ Mise à jour concernant l'acceptation de l'autorisation de marquage le 21 juillet 2017
CodeCommit	18 avril 2016
AWS OpsWorks	2 juin 2016
AWS CloudFormation	3 novembre 2016
AWS CodeBuild	1er décembre 2016
Elastic Beanstalk	Lancement initial du service

Procédez comme suit pour ajouter des autorisations pour un service pris en charge :

Connectez-vous à la console IAM AWS Management Console et ouvrez-la à l'adresse https://console.aws.amazon.com/iam/.
Dans le volet de navigation de la console IAM, sélectionnez Rôles, puis choisissez votre AWS-CodePipeline-Service rôle dans la liste des rôles.
Dans l'onglet Autorisations, dans Politiques intégrées, dans la ligne correspondant à votre politique de rôle de service, choisissez Modifier la politique.

Ajoutez les autorisations requises dans la zone du document de politique.

Note

Lorsque vous créez des politiques IAM, suivez les conseils de sécurité standard qui consistent à accorder le moindre privilège, c'est-à-dire à n'accorder que les autorisations nécessaires à l'exécution d'une tâche. Certains appels d'API prennent en charge les autorisations basées sur les ressources et autorisent la limitation d'accès. Par exemple, dans ce cas, pour limiter les autorisations lors de l'appel de DescribeTasks et de ListTasks, vous pouvez remplacer le caractère générique (*) par un ARN de ressource ou par un ARN de ressource contenant un caractère générique (*). Pour plus d'informations sur la création d'une politique accordant un accès avec le moindre privilège, consultez. https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege

Par exemple, pour obtenir de l' CodeCommit aide, ajoutez ce qui suit à votre déclaration de politique :


{
  "Effect": "Allow",
  "Action": [  
      "codecommit:GetBranch",
      "codecommit:GetCommit",
      "codecommit:UploadArchive",
      "codecommit:GetUploadArchiveStatus",      
      "codecommit:CancelUploadArchive"
            ],
  "Resource": "resource_ARN"
},

Pour obtenir de l' AWS OpsWorks aide, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "opsworks:CreateDeployment",
        "opsworks:DescribeApps",
        "opsworks:DescribeCommands",
        "opsworks:DescribeDeployments",
        "opsworks:DescribeInstances",
        "opsworks:DescribeStacks",
        "opsworks:UpdateApp",
        "opsworks:UpdateStack"
    ],
    "Resource": "resource_ARN"
},

Pour obtenir de l' AWS CloudFormation aide, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "cloudformation:CreateStack",
        "cloudformation:DeleteStack",
        "cloudformation:DescribeStackEvents",
        "cloudformation:DescribeStacks",
        "cloudformation:UpdateStack",
        "cloudformation:CreateChangeSet",
        "cloudformation:DeleteChangeSet",
        "cloudformation:DescribeChangeSet",
        "cloudformation:ExecuteChangeSet",
        "cloudformation:SetStackPolicy",
        "cloudformation:ValidateTemplate",
        "iam:PassRole"
    ],
    "Resource": "resource_ARN"
},

Notez que l'cloudformation:DescribeStackEventsautorisation est facultative. Cela permet à l' AWS CloudFormation action d'afficher un message d'erreur plus détaillé. Cette autorisation peut être révoquée pour le rôle IAM si vous ne souhaitez pas que les détails des ressources apparaissent dans les messages d'erreur du pipeline. Pour plus d’informations, consultez AWS CloudFormation.

Pour obtenir de l' CodeBuild aide, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "codebuild:BatchGetBuilds",
        "codebuild:StartBuild"
    ],
    "Resource": "resource_ARN"
},

Note

Support pour les compilations par lots a été ajouté ultérieurement. Consultez l'étape 11 pour les autorisations à ajouter au rôle de service pour les builds par lots.

Pour obtenir de l' AWS Device Farm aide, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "devicefarm:ListProjects",
        "devicefarm:ListDevicePools",
        "devicefarm:GetRun",
        "devicefarm:GetUpload",
        "devicefarm:CreateUpload",
        "devicefarm:ScheduleRun"
    ],
    "Resource": "resource_ARN"
},

Pour l'assistance de Service Catalog, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "servicecatalog:ListProvisioningArtifacts",
        "servicecatalog:CreateProvisioningArtifact",
        "servicecatalog:DescribeProvisioningArtifact",
        "servicecatalog:DeleteProvisioningArtifact",
        "servicecatalog:UpdateProduct"
    ],
    "Resource": "resource_ARN"
},
{
    "Effect": "Allow",
    "Action": [
        "cloudformation:ValidateTemplate"
    ],
    "Resource": "resource_ARN"
}

Pour le support Amazon ECR, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "ecr:DescribeImages"
    ],
    "Resource": "resource_ARN"
},

Pour Amazon ECS, les autorisations minimales requises pour créer des pipelines avec une action de déploiement Amazon ECS sont les suivantes.
```
{
    "Effect": "Allow",
    "Action": [
        "ecs:DescribeServices",
        "ecs:DescribeTaskDefinition",
        "ecs:DescribeTasks",
        "ecs:ListTasks",
        "ecs:RegisterTaskDefinition",
        "ecs:TagResource",
        "ecs:UpdateService"
    ],
    "Resource": "resource_ARN"
},
```
Vous pouvez choisir d'utiliser l'autorisation de balisage dans Amazon ECS. En vous inscrivant, vous devez accorder les autorisations suivantes :ecs:TagResource. Pour plus d'informations sur la procédure d'inscription et pour déterminer si l'autorisation est requise et si l'autorisation des balises est appliquée, consultez la chronologie des autorisations de balisage dans le guide du développeur Amazon Elastic Container Service.

Vous devez également ajouter les iam:PassRole autorisations permettant d'utiliser les rôles IAM pour les tâches. Pour plus d'informations, consultez le rôle IAM d'exécution des tâches Amazon ECS et les rôles IAM pour les tâches. Utilisez le texte de politique suivant.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": [
                "arn:aws:iam::aws_account_ID:role/ecsTaskExecutionRole_or_TaskRole_name"
            ]
        }
    ]
}
```

En ce qui concerne l'CodeDeployToECSaction (déploiements bleu/vert), les autorisations minimales requises pour créer des pipelines avec une action de déploiement bleu/vert vers CodeDeploy Amazon ECS sont les suivantes.


{
    "Effect": "Allow",
    "Action": [
        "codedeploy:CreateDeployment",
        "codedeploy:GetDeployment",
        "codedeploy:GetApplication",
        "codedeploy:GetApplicationRevision",
        "codedeploy:RegisterApplicationRevision",
        "codedeploy:GetDeploymentConfig",
        "ecs:RegisterTaskDefinition",
        "ecs:TagResource"
    ],
    "Resource": "resource_ARN"
},

Vous pouvez choisir d'utiliser l'autorisation de balisage dans Amazon ECS. En vous inscrivant, vous devez accorder les autorisations suivantes :ecs:TagResource. Pour plus d'informations sur la procédure d'inscription et pour déterminer si l'autorisation est requise et si l'autorisation des balises est appliquée, consultez la chronologie des autorisations de balisage dans le guide du développeur Amazon Elastic Container Service.

Vous devez également ajouter les iam:PassRole autorisations permettant d'utiliser les rôles IAM pour les tâches. Pour plus d'informations, consultez le rôle IAM d'exécution des tâches Amazon ECS et les rôles IAM pour les tâches. Utilisez le texte de politique suivant.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": [
                "arn:aws:iam::aws_account_ID:role/ecsTaskExecutionRole_or_TaskRole_name"
            ]
        }
    ]
}

Vous pouvez également l'ajouter ecs-tasks.amazonaws.com à la liste des services soumis à cette iam:PassedToService condition, comme indiqué dans cet exemple.


{
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "iam:PassRole"
            ],
            "Resource": "resource_ARN",
            "Condition": {
                "StringEqualsIfExists": {
                    "iam:PassedToService": [
                        "cloudformation.amazonaws.com",
                        "elasticbeanstalk.amazonaws.com",
                        "ec2.amazonaws.com",
                        "ecs-tasks.amazonaws.com"
                    ]
                }
            }
        },

Pour AWS CodeStar les connexions, l'autorisation suivante est requise pour créer des pipelines avec une source qui utilise une connexion, telle que Bitbucket Cloud.
```
{
    "Effect": "Allow",
    "Action": [
        "codestar-connections:UseConnection"
    ],
    "Resource": "resource_ARN"
},
```
Pour plus d'informations sur les autorisations IAM pour les connexions, consultez la section Référence des autorisations de connexion.

En ce qui StepFunctions concerne l'action, les autorisations minimales requises pour créer des pipelines avec une action d'appel Step Functions sont les suivantes.


{
    "Effect": "Allow",
    "Action": [
        "states:DescribeStateMachine",
        "states:DescribeExecution",
        "states:StartExecution"
    ],
    "Resource": "resource_ARN"
},

Pour l'AppConfigaction, les autorisations minimales requises pour créer des pipelines avec une action d' AWS AppConfig appel sont les suivantes.


{
    "Effect": "Allow",
    "Action": [
        "appconfig:StartDeployment",
        "appconfig:GetDeployment",
        "appconfig:StopDeployment"
    ],
    "Resource": "resource_ARN"
},

Pour la CodeBuild prise en charge des compilations par lots, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "codebuild:BatchGetBuildBatches",
        "codebuild:StartBuildBatch"
    ],
    "Resource": "resource_ARN"
},

Pour AWS CloudFormation StackSets les actions, les autorisations minimales suivantes sont requises.

Pour l'CloudFormationStackSetaction, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "cloudformation:CreateStackSet",
        "cloudformation:UpdateStackSet",
        "cloudformation:CreateStackInstances",
        "cloudformation:DescribeStackSetOperation",
        "cloudformation:DescribeStackSet",
        "cloudformation:ListStackInstances"
    ],
    "Resource": "resource_ARN"
},

Pour l'CloudFormationStackInstancesaction, ajoutez ce qui suit à votre déclaration de politique :


{
    "Effect": "Allow",
    "Action": [
        "cloudformation:CreateStackInstances",
        "cloudformation:DescribeStackSetOperation"
    ],
    "Resource": "resource_ARN"
},

Pour bénéficier de la prise en CodeCommit charge de l'option de clonage complet, ajoutez ce qui suit à votre déclaration de politique :
```
{
    "Effect": "Allow",
    "Action": [
        "codecommit:GetRepository"
    ],
    "Resource": "resource_ARN"
},
```
Note
Pour vous assurer que votre CodeBuild action peut utiliser l'option de clonage complet avec une CodeCommit source, vous devez également ajouter l'codecommit:GitPullautorisation à la déclaration de politique concernant le rôle de CodeBuild service de votre projet.
Pour Elastic Beanstalk, les autorisations minimales requises pour créer des pipelines avec une action de déploiement sont les suivantes. ElasticBeanstalk
```
{
    "Effect": "Allow",
    "Action": [
        "elasticbeanstalk:*",
        "ec2:*",
        "elasticloadbalancing:*",
        "autoscaling:*",
        "cloudwatch:*",
        "s3:*",
        "sns:*",
        "cloudformation:*",
        "rds:*",
        "sqs:*",
        "ecs:*"
    ],
    "Resource": "resource_ARN"
},
```
Note
Vous devez remplacer les caractères génériques dans la politique de ressources par les ressources du compte auquel vous souhaitez limiter l'accès. Pour plus d'informations sur la création d'une politique accordant un accès avec le moindre privilège, consultez. https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege
Pour un pipeline que vous souhaitez configurer pour les CloudWatch journaux, les autorisations minimales que vous devez ajouter au rôle de CodePipeline service sont les suivantes.
```
{
    "Effect": "Allow",
    "Action": [
        "logs:DescribeLogGroups",
        "logs:PutRetentionPolicy"
    ],
    "Resource": "resource_ARN"
},
```
Note
Vous devez remplacer les caractères génériques dans la politique de ressources par les ressources du compte auquel vous souhaitez limiter l'accès. Pour plus d'informations sur la création d'une politique accordant un accès avec le moindre privilège, consultez. https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege
Choisissez Examiner une stratégie afin de vérifier que la stratégie ne contient aucune erreur. Lorsque la politique est exempte d'erreurs, choisissez Appliquer la politique.

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

AWS Secrets Manager À utiliser pour suivre les mots de passe de base de données ou les clés d'API tierces

Comment AWS CodePipeline fonctionne avec IAM