Création d'une politique de ressources pour accorder l'accès en lecture Définissez une politique Lire une politique Supprimer une politique Accorder un accès en lecture aux principaux Accorder l'accès en écriture aux packages Accorder l'accès en écriture à un dépôt Interaction entre le référentiel et les politiques de domaine

Politiques de référentiel

CodeArtifact utilise des autorisations basées sur les ressources pour contrôler l'accès. Les autorisations basées sur les ressources vous permettent de spécifier qui a accès à un référentiel et quelles actions peuvent être exécutées. Par défaut, seul le propriétaire du référentiel a accès à celui-ci. Vous pouvez appliquer un document de politique permettant aux autres IAM principaux d'accéder à votre référentiel.

Pour plus d'informations, consultez les sections Politiques basées sur les ressources, Stratégies basées sur l'identité et Stratégies basées sur les ressources.

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

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


{
    "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 par rapport au 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 depuis ce référentiel, une politique de domaine pour l'accès entre comptes doit également être créée. La politique de domaine doit au moins accorder une codeartifact:GetAuthorizationToken autorisation au principal. Pour un exemple de politique de domaine complète permettant d'accorder un accès entre comptes, consultez ceciExemple de politique de domaine.

Note

L'codeartifact:ReadFromRepositoryaction ne peut être utilisée que sur une ressource de référentiel. Vous ne pouvez pas mettre le nom de ressource Amazon d'un package (ARN) comme ressource avec codeartifact:ReadFromRepository pour action d'autoriser l'accès en lecture à un sous-ensemble de packages dans un référentiel. Un principal donné peut lire tous les packages d'un dépôt ou aucun d'entre eux.

Étant donné que la seule action spécifiée dans le référentiel est que ReadFromRepository 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). Généralement, 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 d'une autre manière.


{
    "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 de ressources.

Note

Vous ne pouvez pas autoriser un autre AWS compte à mettre à jour la politique de ressources d'un référentiel à l'aide d'une stratégie de ressources, car la politique de ressources est ignorée lors de l'appel put-repository-permissions-policy.

Exemple de sortie :


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

La sortie 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 afin de la rendre lisible, 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 :


{
    "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 sortie est le même que celui de la get-repository-permissions-policy commande.

Accorder un accès en lecture aux principaux

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-les ARN dans la Principal section de la politique. Par exemple, utilisez ce qui suit pour accorder un accès bob en lecture à l'IAMutilisateur du compte123456789012.


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

Accorder l'accès en écriture aux packages

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


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

L'exemple suivant montre le ARN nom @parity et la portée d'un package npm 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

ARNPour un package npm sans portée, la chaîne est vide pour le champ d'espace de noms. Par exemple, ce qui suit ARN concerne un package sans portée et dont le nom se trouve react dans le my_repo référentiel du 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.


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

Important

Pour accorder l'autorisation de publier des versions de Maven et de NuGet package, ajoutez les autorisations suivantes en plus decodeartifact:PublishPackageVersion.

NuGet: codeartifact:ReadFromRepository et spécifiez la ressource du référentiel
Maven : codeartifact:PutPackageMetadata

É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.

Accorder l'accès en écriture à un dépôt

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


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

Interaction entre le référentiel et les politiques de domaine

CodeArtifact prend en charge les politiques de 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 adressée à 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 :

Aucune politique de ressources n'est évaluée lors de l'exécution d'opérations au niveau du compte telles ListDomainsque ou. ListRepositories
Aucune politique de référentiel n'est évaluée lors de l'exécution d'opérations au niveau du domaine telles DescribeDomainque ou. ListRepositoriesInDomain
La politique de domaine n'est pas évaluée lors de l'exécution PutDomainPermissionsPolicy. Notez que cette règle empêche les lock-outs.
La politique de domaine est évaluée lors de l'exécution PutRepositoryPermissionsPolicy, mais la politique de référentiel n'est pas évaluée.
Un refus explicite dans une politique remplace une autorisation dans une autre politique.
Une autorisation explicite n'est requise que dans une seule politique de ressources. L'omission d'une action dans une politique de référentiel n'entraîne pas de refus implicite si la politique de domaine autorise l'action.
Lorsqu'aucune politique de ressources n'autorise une action, le résultat est un refus implicite, sauf si le compte du principal appelant est le propriétaire du domaine ou le compte de l'administrateur du référentiel et qu'une politique basée sur l'identité autorise l'action.

Les politiques de ressources sont facultatives lorsqu'elles sont utilisées pour accorder l'accès dans un scénario de compte unique, où 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 le compte de l'administrateur du référentiel. Des politiques en matière de ressources sont nécessaires pour accorder l'accès dans un scénario multi-comptes où le compte de l'appelant n'est pas le même que le compte du propriétaire du domaine ou de l'administrateur du référentiel. L'accès entre comptes CodeArtifact suit les IAM règles générales relatives à l'accès entre comptes, telles que décrites dans la section Déterminer si une demande entre comptes est autorisée dans le guide de l'IAMutilisateur.

Un titulaire du compte du propriétaire du domaine peut se voir accorder l'accès à n'importe quel référentiel du domaine par le biais d'une politique basée sur l'identité. Notez que dans ce cas, aucune autorisation explicite n'est requise dans une politique de domaine ou de référentiel.
Un utilisateur principal du compte du propriétaire du domaine peut se voir accorder l'accès à n'importe quel référentiel par le biais d'une politique de domaine ou de référentiel. Notez que dans ce cas, aucune autorisation explicite n'est requise dans une politique basée sur l'identité.
Un administrateur principal du compte administrateur du référentiel peut se voir accorder l'accès au référentiel par le biais d'une politique basée sur l'identité. Notez que dans ce cas, aucune autorisation explicite n'est requise dans une politique de domaine ou de référentiel.
Le principal d'un autre compte n'est autorisé à y accéder que s'il est autorisé par au moins une politique de ressources et au moins une politique basée sur l'identité, aucune politique ne refusant explicitement l'action.

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

Afficher ou modifier la configuration d'un référentiel

Marquer un dépôt