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.

Politiques de référentiel

CodeArtifact utilise des autorisations basées sur les ressources pour contrôler l'accès. Resource-basedles autorisations vous permettent de spécifier qui a accès à un référentiel et les actions qu'il peut effectuer sur celui-ci. Par défaut, seul le propriétaire du référentiel a accès à celui-ci. Vous pouvez appliquer un document de politique qui permet à d'autres administrateurs IAM d'accéder à votre référentiel.

Pour plus d'informations, consultez Resource-Based la section Identity-Based Politiques et Resource-Based politiques.

Créez une politique de ressources pour accorder l'accès en lecture

Une politique de ressources est un fichier texte au format JSON. Le fichier doit spécifier un acteur principal, une ou plusieurs actions et un effet (AllowouDeny). Par exemple, la politique de ressources suivante autorise le compte 123456789012 à télécharger des packages depuis le référentiel.

JSON

{
    "Version":"2012-10-17",
    "Statement": [
        {
            "Action": [
                "codeartifact:ReadFromRepository"
            ],
            "Effect": "Allow",
            "Principal": {
                 "AWS": "arn:aws:iam::123456789012:root"
            },
            "Resource": "*"
        }
    ]
}

Comme la politique est évaluée uniquement pour les opérations effectuées sur le référentiel auquel elle est attachée, il n'est pas nécessaire de spécifier de ressource. Comme la ressource est implicite, vous pouvez définir la valeur Resource sur*. Pour qu'un gestionnaire de packages puisse télécharger un package à partir de ce référentiel, une politique de domaine pour l'accès entre comptes devra également être créée. La politique de domaine doit accorder au moins codeartifact:GetAuthorizationToken l'autorisation au principal. Pour un exemple de politique de domaine complète permettant d'accorder l'accès entre comptes, consultez ceciExemple de politique de domaine.

Étant donné que la seule action spécifiée dans le référentiel estReadFromRepository, les utilisateurs et les rôles du compte 1234567890 peuvent télécharger des packages depuis le référentiel. Cependant, ils ne peuvent pas effectuer d'autres actions sur eux (par exemple, répertorier les noms et les versions des packages). En règle générale, vous accordez des autorisations dans le cadre de la politique suivante, en plus du ReadFromRepository fait qu'un utilisateur qui télécharge des packages depuis un référentiel doit également interagir avec celui-ci par d'autres moyens.

JSON

{
    "Version":"2012-10-17",
    "Statement": [
        {
            "Action": [
                "codeartifact:DescribePackageVersion",
                "codeartifact:DescribeRepository",
                "codeartifact:GetPackageVersionReadme",
                "codeartifact:GetRepositoryEndpoint",
                "codeartifact:ListPackages",
                "codeartifact:ListPackageVersions",
                "codeartifact:ListPackageVersionAssets",
                "codeartifact:ListPackageVersionDependencies",
                "codeartifact:ReadFromRepository"
            ],
            "Effect": "Allow",
            "Principal": {
                 "AWS": "arn:aws:iam::123456789012:root"
            },
            "Resource": "*"
        }
    ]
}

Définissez une politique

Après avoir créé un document de politique, utilisez la put-repository-permissions-policy commande pour le joindre à un référentiel :

aws codeartifact put-repository-permissions-policy --domain my_domain --domain-owner 111122223333 \
          --repository my_repo --policy-document file:///PATH/TO/policy.json

Lorsque vous appelezput-repository-permissions-policy, la politique de ressources du référentiel est ignorée lors de l'évaluation des autorisations. Cela garantit que le propriétaire d'un domaine ne peut pas s'exclure du référentiel, ce qui l'empêcherait de mettre à jour la politique en matière de ressources.

Exemple de sortie :

{
    "policy": {
        "resourceArn": "arn:aws:codeartifact:region-id:111122223333:repository/my_domain/my_repo",
        "document": "{ ...policy document content...}",
        "revision": "MQlyyTQRASRU3HB58gBtSDHXG7Q3hvxxxxxxx="
    }
}

Le résultat de la commande contient le nom de ressource Amazon (ARN) de la ressource du référentiel, le contenu complet du document de politique et un identifiant de révision. Vous pouvez transmettre l'identifiant de révision à put-repository-permissions-policy l'aide de l'--policy-revisionoption. Cela garantit qu'une révision connue du document est remplacée, et non une version plus récente définie par un autre rédacteur.

Lire une politique

Utilisez la get-repository-permissions-policy commande pour lire une version existante d'un document de politique. Pour formater la sortie à des fins de lisibilité, utilisez le --output et --query policy.document avec le json.tool module Python.

aws codeartifact get-repository-permissions-policy --domain my_domain --domain-owner 111122223333 \
          --repository my_repo --output text --query policy.document | python -m json.tool

Exemple de sortie :

JSON

{
    "Version":"2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::123456789012:root"
            },
            "Action": [
                "codeartifact:DescribePackageVersion",
                "codeartifact:DescribeRepository",
                "codeartifact:GetPackageVersionReadme",
                "codeartifact:GetRepositoryEndpoint",
                "codeartifact:ListPackages",
                "codeartifact:ListPackageVersions",
                "codeartifact:ListPackageVersionAssets",
                "codeartifact:ListPackageVersionDependencies",
                "codeartifact:ReadFromRepository"
            ],
            "Resource": "*"
        }
    ]
}

Supprimer une politique

Utilisez la delete-repository-permissions-policy commande pour supprimer une politique d'un référentiel.

aws codeartifact delete-repository-permissions-policy --domain my_domain --domain-owner 111122223333 \
          --repository my_repo

Le format de la sortie est le même que celui de la get-repository-permissions-policy commande.

Accorder l'accès en lecture aux directeurs

Lorsque vous spécifiez l'utilisateur root d'un compte comme principal dans un document de politique, vous accordez l'accès à tous les utilisateurs et rôles de ce compte. Pour limiter l'accès à certains utilisateurs ou rôles, utilisez leur ARN dans la Principal section de la politique. Par exemple, utilisez ce qui suit pour accorder un accès en lecture à l'utilisateur bob IAM du compte123456789012.

JSON

{
    "Version":"2012-10-17",
    "Statement": [
        {
            "Action": [
                "codeartifact:ReadFromRepository"
            ],
            "Effect": "Allow",
            "Principal": {
                 "AWS": "arn:aws:iam::123456789012:user/bob"
            },
            "Resource": "*"
        }
    ]
}

Autoriser l'accès en écriture aux packages

L'codeartifact:PublishPackageVersionaction est utilisée pour contrôler l'autorisation de publier de nouvelles versions d'un package. La ressource utilisée pour cette action doit être un package. Le format des CodeArtifact ARN des packages est le suivant.

arn:aws:codeartifact:region-id:111122223333:package/my_domain/my_repo/package-format/package-namespace/package-name

L'exemple suivant montre l'ARN d'un package npm avec une portée @parity et un nom ui dans le my_repo référentiel du domainemy_domain.

arn:aws:codeartifact:region-id:111122223333:package/my_domain/my_repo/npm/parity/ui

L'ARN d'un package npm sans portée contient la chaîne vide pour le champ d'espace de noms. Par exemple, voici l'ARN d'un package sans étendue et dont le nom figure react dans le my_repo référentiel en tant que domainemy_domain.

arn:aws:codeartifact:region-id:111122223333:package/my_domain/my_repo/npm//react

La politique suivante autorise le compte 123456789012 à publier des versions de @parity/ui dans le my_repo référentiel.

JSON

{
    "Version":"2012-10-17",
    "Statement": [
        {
            "Action": [
                "codeartifact:PublishPackageVersion"
            ],
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::123456789012:root"
            },
            "Resource": "arn:aws:codeartifact:us-east-1:111122223333:package/my_domain/my_repo/npm/parity/ui"
        }
    ]
}

Étant donné que cette politique spécifie un domaine et un référentiel dans le cadre de la ressource, elle autorise la publication uniquement lorsqu'ils sont attachés à ce référentiel.

Autoriser l'accès en écriture à un référentiel

Vous pouvez utiliser des caractères génériques pour accorder l'autorisation d'écriture à tous les packages d'un référentiel. Par exemple, utilisez la politique suivante pour autoriser un compte à écrire dans tous les packages du my_repo référentiel.

JSON

{
    "Version":"2012-10-17",
    "Statement": [
        {
            "Action": [
                "codeartifact:PublishPackageVersion"
            ],
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::123456789012:root"
            },
            "Resource": "arn:aws:codeartifact:us-east-1:111122223333:package/my_domain/my_repo/*"
        }
    ]
}

Interaction entre les politiques du référentiel et du domaine

CodeArtifact prend en charge les politiques relatives aux ressources sur les domaines et les référentiels. Les politiques relatives aux ressources sont facultatives. Chaque domaine peut avoir une politique et chaque référentiel du domaine peut avoir sa propre politique de référentiel. Si une politique de domaine et une politique de référentiel sont présentes, les deux sont évaluées pour déterminer si une demande à un CodeArtifact référentiel est autorisée ou refusée. Les politiques de domaine et de référentiel sont évaluées selon les règles suivantes :

Les politiques de ressources sont facultatives lorsqu'elles sont utilisées pour accorder l'accès dans un scénario de compte unique, dans lequel le compte de l'appelant utilisé pour accéder à un référentiel est le même que le compte du propriétaire du domaine et de l'administrateur du référentiel. Des politiques relatives aux ressources sont requises pour accorder l'accès dans un scénario multicompte où le compte de l'appelant n'est pas le même que celui du propriétaire du domaine ou de l'administrateur du référentiel. Cross-account access in CodeArtifact suit les règles IAM générales pour l'accès entre comptes, comme décrit dans Déterminer si une demande entre comptes est autorisée dans le Guide de l'utilisateur IAM.