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.

Exemples de politiques basées sur l'identité pour AWS CodeArtifact

Par défaut, les utilisateurs et les rôles ne sont pas autorisés à créer ou à modifier CodeArtifact des ressources. Ils ne peuvent pas non plus effectuer de tâches en utilisant le AWS Management Console, AWS Command Line Interface (AWS CLI) ou AWS API. Pour autoriser les utilisateurs à effectuer des actions sur les ressources dont ils ont besoin, un IAM administrateur peut créer des IAM politiques. L'administrateur peut ensuite ajouter les IAM politiques aux rôles, et les utilisateurs peuvent assumer les rôles.

Pour savoir comment créer une politique IAM basée sur l'identité à l'aide de ces exemples de documents de JSON stratégie, voir Créer des IAM politiques (console) dans le guide de l'IAMutilisateur.

Pour plus de détails sur les actions et les types de ressources définis par CodeArtifact, y compris le format de ARNs pour chacun des types de ressources, voir Actions, ressources et clés de condition AWS CodeArtifact dans la référence d'autorisation de service.

Bonnes pratiques en matière de politiques

Les politiques basées sur l'identité déterminent si quelqu'un peut créer, accéder ou supprimer CodeArtifact des ressources dans votre compte. Ces actions peuvent entraîner des frais pour votre Compte AWS. Lorsque vous créez ou modifiez des politiques basées sur l’identité, suivez ces instructions et recommandations :

Pour plus d'informations sur les meilleures pratiques en matière de sécuritéIAM, consultez la section Bonnes pratiques en matière de sécurité IAM dans le Guide de IAM l'utilisateur.

Utilisation de la CodeArtifact console

Pour accéder à la AWS CodeArtifact console, vous devez disposer d'un ensemble minimal d'autorisations. Ces autorisations doivent vous permettre de répertorier et d'afficher les détails CodeArtifact des ressources de votre Compte AWS. Si vous créez une politique basée sur l’identité qui est plus restrictive que l’ensemble minimum d’autorisations requis, la console ne fonctionnera pas comme prévu pour les entités (utilisateurs ou rôles) tributaires de cette politique.

Il n'est pas nécessaire d'accorder des autorisations de console minimales aux utilisateurs qui passent des appels uniquement vers le AWS CLI ou le AWS API. Au lieu de cela, autorisez uniquement l'accès aux actions correspondant à l'APIopération qu'ils tentent d'effectuer.

Pour garantir que les utilisateurs et les rôles peuvent toujours utiliser la CodeArtifact console, associez également la politique AWSCodeArtifactAdminAccess ou la politique AWSCodeArtifactReadOnlyAccess AWS gérée aux entités. Pour plus d'informations, consultez la section Ajouter des autorisations à un utilisateur dans le Guide de IAM l'utilisateur.

AWSpolitiques gérées (prédéfinies) pour AWS CodeArtifact

AWS répond à de nombreux cas d'utilisation courants en fournissant des IAM politiques autonomes créées et administrées par AWS. Ces politiques AWS gérées accordent les autorisations nécessaires pour les cas d'utilisation courants afin que vous n'ayez pas à rechercher les autorisations nécessaires. Pour plus d'informations, consultez la section Politiques AWS gérées dans le guide de IAM l'utilisateur.

Les politiques AWS gérées suivantes, que vous pouvez associer aux utilisateurs de votre compte, sont spécifiques à AWS CodeArtifact.

Pour créer et gérer des rôles de CodeArtifact service, vous devez également associer la politique AWS gérée nomméeIAMFullAccess.

Vous pouvez également créer vos propres IAM politiques personnalisées pour autoriser les CodeArtifact actions et les ressources. Vous pouvez associer ces politiques personnalisées aux IAM utilisateurs ou aux groupes qui ont besoin de ces autorisations.

Autoriser un utilisateur à consulter ses propres autorisations

Cet exemple montre comment créer une politique qui permet aux IAM utilisateurs de consulter les politiques intégrées et gérées associées à leur identité d'utilisateur. Cette politique inclut les autorisations permettant d'effectuer cette action sur la console ou par programmation à l'aide du AWS CLI ou. AWS API

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "ViewOwnUserInfo",
            "Effect": "Allow",
            "Action": [
                "iam:GetUserPolicy",
                "iam:ListGroupsForUser",
                "iam:ListAttachedUserPolicies",
                "iam:ListUserPolicies",
                "iam:GetUser"
            ],
            "Resource": ["arn:aws:iam::*:user/${aws:username}"]
        },
        {
            "Sid": "NavigateInConsole",
            "Effect": "Allow",
            "Action": [
                "iam:GetGroupPolicy",
                "iam:GetPolicyVersion",
                "iam:GetPolicy",
                "iam:ListAttachedGroupPolicies",
                "iam:ListGroupPolicies",
                "iam:ListPolicyVersions",
                "iam:ListPolicies",
                "iam:ListUsers"
            ],
            "Resource": "*"
        }
    ]
}

Autoriser un utilisateur à obtenir des informations sur les référentiels et les domaines

La politique suivante permet à un IAM utilisateur ou à un rôle de répertorier et de décrire tout type de CodeArtifact ressource, y compris les domaines, les référentiels, les packages et les actifs. La politique inclut également l'codeArtifact:ReadFromRepositoryautorisation, qui permet au principal de récupérer des packages depuis un CodeArtifact référentiel. Il n'autorise pas la création de nouveaux domaines ou référentiels et n'autorise pas la publication de nouveaux packages.

Les sts:GetServiceBearerToken autorisations codeartifact:GetAuthorizationToken et sont requises pour appeler le GetAuthorizationTokenAPI.

{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Effect": "Allow",
         "Action": [
            "codeartifact:List*",
            "codeartifact:Describe*",
            "codeartifact:Get*",
            "codeartifact:Read*"
         ],
         "Resource": "*"      
      },
      {
         "Effect": "Allow",
         "Action": "sts:GetServiceBearerToken",
         "Resource": "*",
         "Condition": {
            "StringEquals": {
               "sts:AWSServiceName": "codeartifact.amazonaws.com"
            }
         }
      }
   ]
}

Autoriser un utilisateur à obtenir des informations sur des domaines spécifiques

Voici un exemple de politique d'autorisation qui permet à un utilisateur de répertorier des domaines uniquement dans la us-east-2 région pour créer un compte 123456789012 pour tout domaine commençant par le nommy.

{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Effect": "Allow",
         "Action": "codeartifact:ListDomains",
         "Resource": "arn:aws:codeartifact:us-east-2:123456789012:domain/my*"      
      }
   ]
}

Autoriser un utilisateur à obtenir des informations sur des référentiels spécifiques

Voici un exemple de politique d'autorisation qui permet à un utilisateur d'obtenir des informations sur les référentiels se terminant partest, notamment des informations sur les packages qu'ils contiennent. L'utilisateur ne sera pas en mesure de publier, de créer ou de supprimer des ressources.

Les sts:GetServiceBearerToken autorisations codeartifact:GetAuthorizationToken et sont requises pour appeler le GetAuthorizationTokenAPI.

{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Effect": "Allow",
         "Action": [
            "codeartifact:List*",
            "codeartifact:Describe*",
            "codeartifact:Get*",
            "codeartifact:Read*"
         ],
         "Resource": "arn:aws:codeartifact:*:*:repository/*/*test"      
      },
      {
         "Effect": "Allow",
         "Action": [
            "codeartifact:List*",
            "codeartifact:Describe*"
         ],
         "Resource": "arn:aws:codeartifact:*:*:package/*/*test/*/*/*"   
      },
      {
         "Effect": "Allow",
         "Action": "sts:GetServiceBearerToken",
         "Resource": "*",
         "Condition": {
            "StringEquals": {
               "sts:AWSServiceName": "codeartifact.amazonaws.com"
            }
         }
      },
      {
         "Effect": "Allow",
         "Action": "codeartifact:GetAuthorizationToken",
         "Resource": "*"
      }
   ]
}

Limiter la durée du jeton d'autorisation

Les utilisateurs doivent s'authentifier à l' CodeArtifact aide de jetons d'autorisation pour publier ou consommer des versions de packages. Les jetons d'autorisation ne sont valides que pendant leur durée de vie configurée. Les jetons ont une durée de vie par défaut de 12 heures. Pour plus d'informations sur les jetons d'autorisation, consultezAWS CodeArtifact authentification et jetons.

Lors de la récupération d'un jeton, les utilisateurs peuvent configurer la durée de vie du jeton. Les valeurs valides pour la durée de vie d'un jeton d'autorisation sont0, et tout nombre compris entre 900 (15 minutes) et 43200 (12 heures). La valeur de 0 créera un jeton d'une durée égale aux informations d'identification temporaires du rôle de l'utilisateur.

Les administrateurs peuvent limiter les valeurs valides pendant la durée de vie d'un jeton d'autorisation en utilisant la clé de sts:DurationSeconds condition figurant dans la politique d'autorisation attachée à l'utilisateur ou au groupe. Si l'utilisateur tente de créer un jeton d'autorisation dont la durée de vie est supérieure aux valeurs valides, la création du jeton échouera.

Les exemples de politiques suivants limitent les durées possibles d'un jeton d'autorisation créé par CodeArtifact les utilisateurs.

Exemple de politique : limiter la durée de vie du jeton à exactement 12 heures (43 200 secondes)

Avec cette politique, les utilisateurs ne pourront créer que des jetons d'autorisation d'une durée de vie de 12 heures.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "codeartifact:*",
            "Resource": "*"
        },
        {
            "Sid": "sts",
            "Effect": "Allow",
            "Action": "sts:GetServiceBearerToken",
            "Resource": "*",
            "Condition": {
                "NumericEquals": {
                    "sts:DurationSeconds": 43200
                },
                "StringEquals": {
                    "sts:AWSServiceName": "codeartifact.amazonaws.com"
                }
            }
        }
    ]
}
           

Exemple de politique : Limiter la durée de vie du jeton entre 15 minutes et 1 heure, ou égale à la période d'identification temporaire de l'utilisateur

Grâce à cette politique, les utilisateurs pourront créer des jetons valides entre 15 minutes et 1 heure. Les utilisateurs pourront également créer un jeton qui durera la durée des informations d'identification temporaires de leur rôle en spécifiant 0 pour--durationSeconds.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "codeartifact:*",
            "Resource": "*"
        },
        {
            "Sid": "sts",
            "Effect": "Allow",
            "Action": "sts:GetServiceBearerToken",
            "Resource": "*",
            "Condition": {
                "NumericLessThanEquals": {
                    "sts:DurationSeconds": 3600
                },
                "StringEquals": {
                    "sts:AWSServiceName": "codeartifact.amazonaws.com"
                }
            }
        }
    ]
}