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 principaux IAM d'accéder à votre référentiel.

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

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 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 (ARN) d'un package en tant codeartifact:ReadFromRepository que ressource dans le but d'autoriser l'accès en lecture à un sous-ensemble de packages d'un référentiel. Un principal donné peut lire tous les packages d'un dépôt ou aucun d'entre eux.

Comme 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 l'Amazon Resource Name (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 leur ARN dans la Principal section de la politique. Par exemple, utilisez ce qui suit pour accorder un accès en lecture à l'utilisateur IAM bob dans le 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 des CodeArtifact ARN du package 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 la portée @parity et le 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 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.

1. NuGet: codeartifact:ReadFromRepository et spécifiez la ressource du référentiel

2. 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 à l'aide des 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 règles générales IAM 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'utilisateur IAM.

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