As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Segurança no AWS CodeCommit
A segurança na nuvem da AWS é nossa maior prioridade. Como cliente da AWS, você se beneficiará de um data center e de uma arquitetura de rede criados para atender aos requisitos das empresas com as maiores exigências de segurança.
A segurança é uma responsabilidade compartilhada entre a AWS e você. O [modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) descreve isso como segurança *da* nuvem e segurança *na* nuvem:
+ **Segurança da nuvem**: a AWS é responsável pela proteção da infraestrutura que executa serviços AWS na Nuvem AWS. A AWS também fornece serviços que podem ser usados com segurança. Auditores terceirizados testam e verificam regularmente a eficácia da nossa segurança como parte dos [Programas de conformidade da AWS](https://aws.amazon.com/compliance/programs/). Para saber mais sobre os programas de conformidade que se aplicam ao AWS CodeCommit, consulte [Serviços da AWS em escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/).
+ **Segurança na nuvem**: sua responsabilidade é determinada pelo serviço da AWS que você usa. Você também é responsável por outros fatores, incluindo a confidencialidade de seus dados, os requisitos da empresa e as leis e regulamentos aplicáveis.
Esta documentação ajuda a entender como aplicar o modelo de responsabilidade compartilhada ao usar o CodeCommit. Os tópicos a seguir mostram como configurar o CodeCommit para atender aos seus objetivos de segurança e conformidade. Saiba também como usar outros produtos da AWS que ajudam a monitorar e proteger os recursos do CodeCommit.
**Topics**
+ [Proteção de dados no AWS CodeCommit](data-protection.md)
+ [Identity and Access Management para AWS CodeCommit](security-iam.md)
+ [Resiliência no AWS CodeCommit](disaster-recovery-resiliency.md)
+ [Segurança da infraestrutura no AWS CodeCommit](infrastructure-security.md)
# Proteção de dados no AWS CodeCommit
Por ser um serviço gerenciado, é protegido pela segurança da rede global da AWS. Para obter informações sobre serviços de segurança da AWS e como a AWS protege a infraestrutura, consulte [Segurança na Nuvem AWS](https://aws.amazon.com/security/). Para projetar seu ambiente da AWS usando as práticas recomendadas de segurança da infraestrutura, consulte [Proteção de Infraestrutura](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) em *Pilar de Segurança: AWS Well‐Architected Framework*.
Você usa chamadas de API publicadas pela AWS para acessar por meio da rede. Os clientes devem oferecer compatibilidade com:
+ Transport Layer Security (TLS). Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Conjuntos de criptografia com perfect forward secrecy (PFS) como DHE (Ephemeral Diffie-Hellman) ou ECDHE (Ephemeral Elliptic Curve Diffie-Hellman). A maioria dos sistemas modernos, como Java 7 e versões posteriores, comporta esses modos.
Os repositórios do CodeCommit são criptografados automaticamente quando estão em repouso. Não será necessária nenhuma ação do cliente. O CodeCommit também criptografa dados em trânsito do repositório. Também é possível usar o protocolo HTTPS, o protocolo SSH ou ambos com repositórios do CodeCommit. Para obter mais informações, consulte [Configuração do AWS CodeCommit](setting-up.md). Também é possível configurar o [acesso entre contas](cross-account.md) para repositórios do CodeCommit.
**Topics**
+ [AWS Key Management Service e criptografia para AWS CodeCommit repositórios](encryption.md)
+ [Conectando-se a AWS CodeCommit repositórios com credenciais rotativas](temporary-access.md)
# AWS Key Management Service e criptografia para AWS CodeCommit repositórios
Os dados nos CodeCommit repositórios são criptografados em trânsito e em repouso. Quando os dados são enviados para um CodeCommit repositório (por exemplo, por meio de uma chamada**git push**), CodeCommit criptografa os dados recebidos à medida que são armazenados no repositório. Quando os dados são extraídos de um CodeCommit repositório (por exemplo, por meio de uma chamada**git pull**), os CodeCommit descriptografa e os envia para o chamador. Isso pressupõe que o usuário do IAM associado à solicitação push ou pull tenha sido autenticado por. AWS Os dados enviados ou recebidos são transferidos usando protocolos de rede criptografada HTTPS ou SSH.
Você pode usar uma chave gerenciada pelo cliente Chave gerenciada pela AWS ou uma chave gerenciada pelo cliente para criptografar e descriptografar os dados no seu repositório. Consulte mais informações sobre as diferenças entre chaves gerenciadas pelo cliente e Chaves gerenciadas pela AWS em [Customer managed keys and Chaves gerenciadas pela AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-mgmt). Se você não especificar uma chave gerenciada pelo cliente, CodeCommit usará uma Chave gerenciada pela AWS para criptografar e descriptografar os dados no seu repositório. Essa Chave gerenciada pela AWS é criada automaticamente para você em sua Conta da AWS. Na primeira vez que você cria um CodeCommit repositório em um novo Região da AWS em sua conta da Amazon Web Services, se você não especificar uma chave gerenciada pelo cliente, CodeCommit cria uma Chave gerenciada pela AWS (a `aws/codecommit` chave) na mesma Região da AWS em AWS Key Management Service (AWS KMS). Essa `aws/codecommit` chave é usada somente por CodeCommit. Ela é armazenada na sua conta da Amazon Web Services. Dependendo do que você especificar, CodeCommit use a chave gerenciada pelo cliente ou a Chave gerenciada pela AWS para criptografar e descriptografar os dados no repositório.
**Importante**
CodeCommit executa as seguintes AWS KMS ações em relação à AWS KMS chave usada para criptografar e descriptografar dados em um repositório. Se você estiver usando um Chave gerenciada pela AWS, o usuário não precisará de permissões explícitas para essas ações, mas o usuário não deve ter nenhuma política anexada que negue essas ações para a `aws/codecommit` chave. Se você estiver usando uma chave gerenciada pelo cliente que tenha uma Conta da AWS ID definida como principal de política para essa chave, essas permissões devem ser definidas explicitamente como. `allow` Especificamente, ao criar seu primeiro repositório e atualizar as chaves do seu repositório, você não deve ter nenhuma das seguintes permissões definidas `deny` se estiver usando uma Chave gerenciada pela AWS, e deverá ser definida como `allow` se estiver usando uma chave gerenciada pelo cliente com um diretor de política:
`"kms:Encrypt"`
`"kms:Decrypt"`
`"kms:ReEncrypt"` (dependendo do contexto, pode exigir `kms:ReEncryptFrom`,
`kms:ReEncryptTo` ou `kms:ReEncrypt*` não configurado para negar)
`"kms:GenerateDataKey"`
`"kms:GenerateDataKeyWithoutPlaintext"`
`"kms:DescribeKey"`
Se você quiser usar sua própria chave gerenciada pelo cliente, a chave deve estar disponível no Região da AWS local onde o repositório existe. CodeCommit suporta o uso de chaves gerenciadas pelo cliente de uma e várias regiões. Embora todos os tipos de origem de material de chaves sejam compatíveis, recomendamos usar a opção padrão **KMS**. Se os clientes usarem a opção **Repositório de chaves externo** poderá haver atrasos por parte do fornecedor da loja. Além disso. CodeCommit tem os seguintes requisitos para chaves gerenciadas pelo cliente:
+ CodeCommit só suporta o uso de teclas simétricas.
+ O tipo de uso da chave deve ser definido como **Criptografar e descriptografar**.
Consulte mais informações sobre como criar chaves gerenciadas pelo cliente em [Concepts](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-mgmt) e [Creating keys](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html).
Para ver as informações sobre o Chave gerenciada pela AWS gerado por CodeCommit, faça o seguinte:
1. Faça login no console Console de gerenciamento da AWS e abra o AWS Key Management Service (AWS KMS) em [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms).
1. Para alterar o Região da AWS, use o seletor de região no canto superior direito da página.
1. No painel de navegação de serviço, selecione **Chaves gerenciadas pela AWS**. Verifique se você está conectado ao Região da AWS local em que deseja revisar as chaves.
1. Na lista de chaves de criptografia, escolha a Chave gerenciada pela AWS com o alias **aws/codecommit**. As informações básicas sobre o Chave pertencente à AWS são exibidas.
Você não pode alterar ou excluir isso Chave gerenciada pela AWS.
## Como os algoritmos de criptografia são usados para criptografar dados do repositório
CodeCommit usa duas abordagens diferentes para criptografar dados. Objetos Git individuais com menos de 6 MB são criptografados usando AES-GCM-256, que fornece validação de integridade de dados. Objetos entre 6 MB e o máximo de 2 GB para um único blob são criptografados usando AES-CBC-256. CodeCommit sempre valida o contexto de criptografia.
## Contexto de criptografia
Cada serviço integrado ao AWS KMS especifica um contexto de criptografia para as operações de criptografia e descriptografia. O contexto de criptografia significa informações adicionais autenticadas que o AWS KMS usa para verificar a integridade dos dados. Quando especificado para a operação de criptografia, ele também deve ser especificado na operação de descriptografia. Caso contrário, a decodificação falhará. CodeCommit usa o ID do CodeCommit repositório para o contexto de criptografia. Você pode usar o **get-repository** comando ou o CodeCommit console para encontrar o ID do repositório. Pesquise o ID do CodeCommit repositório nos AWS CloudTrail registros para entender quais operações de criptografia foram realizadas em qual chave AWS KMS para criptografar ou descriptografar dados no repositório. CodeCommit
Para obter mais informações sobre AWS KMS, consulte o [Guia do AWS Key Management Service desenvolvedor](https://docs.aws.amazon.com/kms/latest/developerguide/).
# Conectando-se a AWS CodeCommit repositórios com credenciais rotativas
Você pode dar aos usuários acesso aos seus AWS CodeCommit repositórios sem configurar usuários do IAM para eles ou usar uma chave de acesso e uma chave secreta. Para atribuir permissões a identidades federadas, você cria um perfil e define permissões para a perfil. Quando uma identidade federada é autenticada, essa identidade é associada ao perfil e recebe as permissões definidas por ele. Para ter mais informações sobre perfis para federação, consulte [Criar um perfil para um provedor de identidade de terceiros (federação)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) no *Guia do usuário do IAM*. Se usar o Centro de Identidade do IAM, configure um conjunto de permissões. Para controlar o que suas identidades podem acessar após a autenticação, o Centro de Identidade do IAM correlaciona o conjunto de permissões a um perfil no IAM. Para obter informações sobre conjuntos de permissões, consulte [Conjuntos de Permissões](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) no *Guia do Usuário do Centro de Identidade do AWS IAM *. Você também pode configurar o acesso baseado em funções para que os usuários do IAM acessem CodeCommit repositórios em contas separadas da Amazon Web Services (uma técnica conhecida como acesso *entre* contas). Para obter uma explicação detalhada sobre como configurar o acesso entre várias contas de um repositório, consulte [Configurar o acesso entre contas a um AWS CodeCommit repositório usando funções](cross-account.md).
É possível configurar o acesso para usuários que desejam ou devem ser autenticados por meio de métodos como:
+ Security Assertion Markup Language (SAML)
+ Autenticação multifatorial (MFA)
+ Federação
+ Login da Amazon
+ Amazon Cognito
+ Facebook
+ Google
+ Provedor de identidade compatível com OpenID Connect (OIDC)
**nota**
As informações a seguir se aplicam somente ao uso **git-remote-codecommit** ou ao auxiliar de AWS CLI credenciais para se conectar aos CodeCommit repositórios. Como a abordagem recomendada para acesso temporário ou federado CodeCommit é a configuração**git-remote-codecommit**, este tópico fornece exemplos de uso desse utilitário. Para obter mais informações, consulte [Etapas de configuração para conexões HTTPS AWS CodeCommit com git-remote-codecommit](setting-up-git-remote-codecommit.md).
Você não pode usar credenciais SSH ou Git e HTTPS para se conectar a repositórios com credenciais de CodeCommit acesso rotativo ou temporário.
Não será necessário executar estas etapas se todas as seguintes condições forem verdadeiras:
+ Você está conectado a uma instância do Amazon EC2.
+ Você está usando o Git e o HTTPS com o auxiliar de AWS CLI credenciais para se conectar da instância do Amazon EC2 aos repositórios. CodeCommit
+ A instância do Amazon EC2 tem um perfil de instância do IAM anexado que contém as permissões de acesso descritas em [Para conexões HTTPS no Linux, macOS ou Unix com o auxiliar de credenciais AWS CLI ](setting-up-https-unixes.md) ou [Para conexões HTTPS no Windows com o auxiliar de AWS CLI credenciais](setting-up-https-windows.md).
+ Você instalou e configurou o assistente de credenciais do Git na instância do Amazon EC2, conforme descrito em [Para conexões HTTPS no Linux, macOS ou Unix com o auxiliar de credenciais AWS CLI ](setting-up-https-unixes.md) ou [Para conexões HTTPS no Windows com o auxiliar de AWS CLI credenciais](setting-up-https-windows.md).
As instâncias do Amazon EC2 que atendem aos requisitos anteriores já estão configuradas para comunicar credenciais de acesso temporário em seu CodeCommit nome.
**nota**
Você pode configurar e usar **git-remote-codecommit** em instâncias do Amazon EC2.
Para dar aos usuários acesso temporário aos seus CodeCommit repositórios, conclua as etapas a seguir.
## Etapa 1: Concluir os pré-requisitos
Conclua as etapas de configuração para fornecer ao usuário acesso aos seus CodeCommit repositórios usando credenciais rotativas:
+ Para acesso entre contas, consulte [Passo a passo: delegar acesso entre contas da Amazon Web Services usando perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-walkthrough-crossacct.html) e [Configurar o acesso entre contas a um AWS CodeCommit repositório usando funções](cross-account.md).
+ Para SAML e federação, consulte [Usando o sistema de autenticação da sua organização para conceder acesso a AWS recursos e Sobre a](https://docs.aws.amazon.com/STS/latest/UsingSTS/STSUseCases.html#IdentityBrokerApplication) [federação baseada em AWS STS SAML 2.0.](https://docs.aws.amazon.com/STS/latest/UsingSTS/CreatingSAML.html)
+ Para saber mais sobre MFA, consulte [Usar dispositivos de autenticação multifator (MFA) com a AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_ManagingMFA.html) e [Criar credencias de segurança temporárias para habilitar o acesso de usuários do IAM](https://docs.aws.amazon.com/STS/latest/UsingSTS/CreatingSessionTokens.html).
+ [Para Login com Amazon, Amazon Cognito, Facebook, Google ou qualquer provedor de identidade compatível com OIDC, consulte Sobre a Web Identity Federation. AWS STS](https://docs.aws.amazon.com/STS/latest/UsingSTS/web-identity-federation.html)
Use as informações em [Autenticação e controle de acesso para AWS CodeCommit](auth-and-access-control.md) para especificar as CodeCommit permissões que você deseja conceder ao usuário.
## Etapa 2: obter nome do perfil ou credenciais de acesso
Se você quiser que seus usuários acessem repositórios assumindo uma função, forneça aos usuários o nome de recurso da Amazon (ARN) dessa função. Caso contrário, dependendo da forma como você configura o acesso, seu usuário pode obter credenciais rotativas de uma das seguintes maneiras:
+ Para acesso entre contas, chame o comando AWS CLI [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) ou chame a API. AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
+ Para SAML, chame o AWS CLI [assume-role-with-saml](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-saml.html)comando ou a API AWS STS [AssumeRoleWithSAML.](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html)
+ Para federação, chame os [get-federation-token](https://docs.aws.amazon.com/cli/latest/reference/sts/get-federation-token.html)comandos AWS CLI [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) ou ou. AWS STS [AssumeRole[GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html)](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) APIs
+ Para MFA, chame o AWS CLI [get-session-token](https://docs.aws.amazon.com/cli/latest/reference/sts/get-session-token.html)comando ou a AWS STS [GetSessionToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetSessionToken.html)API.
+ Para Login with Amazon, Amazon Cognito, Facebook, Google ou qualquer provedor de identidade compatível com OIDC, chame o comando AWS CLI [assume-role-with-web-identity](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html) ou a API. AWS STS [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)
## Etapa 3: instalar git-remote-codecommit e configurar o AWS CLI
É necessário configurar o computador local para usar as credenciais de acesso instalando [https://pypi.org/project/git-remote-codecommit/](https://pypi.org/project/git-remote-codecommit/) e configurando um perfil na AWS CLI.
1. Siga as instruções em [Configurando ](setting-up.md) para configurar a AWS CLI. Use o comando **aws configure** para configurar um ou mais perfis. Considere criar um perfil nomeado para usar ao se conectar aos CodeCommit repositórios usando credenciais rotativas.
1. Você pode associar as credenciais ao perfil AWS CLI nomeado do usuário de uma das seguintes formas.
+ Se você estiver assumindo uma função para acessar CodeCommit, configure um perfil nomeado com as informações necessárias para assumir essa função. Por exemplo, se você quiser assumir uma função nomeada *CodeCommitAccess* na conta 11111111111111 da Amazon Web Services, você pode configurar um perfil padrão para usar ao trabalhar com outros AWS recursos e um perfil nomeado para usar ao assumir essa função. Os comandos a seguir criam um perfil nomeado chamado *CodeAccess* que assume uma função chamada*CodeCommitAccess*. O nome do usuário *Maria\$1Garcia* está associado à sessão e o perfil padrão é definido como a origem de suas AWS credenciais:
```
aws configure set role_arn arn:aws:iam::111111111111:role/CodeCommitAccess --profile CodeAccess
aws configure set source_profile default --profile CodeAccess
aws configure set role_session_name "Maria_Garcia" --profile CodeAccess
```
Se você quiser verificar as alterações, visualize ou edite manualmente o arquivo `~/.aws/config` (para Linux) ou o arquivo `%UserProfile%.aws\config` (para Windows) e revise as informações sob o perfil nomeado. Por exemplo, o arquivo pode ser semelhante ao seguinte:
```
[default]
region = us-east-1
output = json
[profile CodeAccess]
source_profile = default
role_session_name = Maria_Garcia
role_arn = arn:aws:iam::111111111111:role/CodeCommitAccess
```
Depois de configurar seu perfil nomeado, você poderá clonar repositórios do CodeCommit com o utilitário **git-remote-codecommit** usando o perfil nomeado. Por exemplo, para excluir um repositório denominado *MyDemoRepo*:
```
git clone codecommit://CodeAccess@MyDemoRepo
```
+ Se você estiver usando a federação de identidade da web e o OpenID Connect (OIDC), configure um perfil nomeado que faça a chamada da `AssumeRoleWithWebIdentity` API AWS Security Token Service (AWS STS) em seu nome para atualizar as credenciais temporárias. Use o **aws configure set** comando ou edite manualmente o `~/.aws/credentials` arquivo (para Linux) ou o `%UserProfile%.aws\credentials` arquivo (para Windows) para adicionar um perfil AWS CLI nomeado com os valores de configuração necessários. Por exemplo, para criar um perfil que assume a *CodeCommitAccess* função e usa um arquivo de token de identidade da web \$1/: *my-credentials* */my-token-file*
```
[CodeCommitWebIdentity]
role_arn = arn:aws:iam::111111111111:role/CodeCommitAccess
web_identity_token_file=~/my-credentials/my-token-file
role_session_name = Maria_Garcia
```
Para obter mais informações, consulte [Configurar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) e [Usar um perfil do IAM na AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html) no *Guia do usuário do AWS Command Line Interface *.
## Etapa 4: acessar os CodeCommit repositórios
Supondo que seu usuário tenha seguido as instruções [Conexão a um repositório](how-to-connect.md) para se conectar aos CodeCommit repositórios, o usuário então usa a funcionalidade estendida fornecida pelo **git-remote-codecommit** Git para chamar **git clone****git push**, **git pull** clonar, enviar e extrair dos CodeCommit repositórios aos quais ele ou ela tem acesso. Por exemplo, para clonar um repositório:
```
git clone codecommit://CodeAccess@MyDemoRepo
```
Os comandos commit, push e pull do Git usam sintaxe regular do Git.
Quando o usuário usa AWS CLI e especifica o perfil AWS CLI nomeado associado às credenciais de acesso rotativas, os resultados com escopo para esse perfil são retornados.
# Identity and Access Management para AWS CodeCommit
AWS Identity and Access Management (IAM) é uma ferramenta AWS service (Serviço da AWS) que ajuda o administrador a controlar com segurança o acesso aos AWS recursos. Os administradores do IAM controlam quem pode ser *autenticado* (conectado) e *autorizado* (tem permissões) a usar CodeCommit os recursos. O IAM é um AWS service (Serviço da AWS) que você pode usar sem custo adicional.
**Topics**
+ [Público](#security_iam_audience)
+ [Autenticação com identidades](#security_iam_authentication)
+ [Gerenciar o acesso usando políticas](#security_iam_access-manage)
+ [Autenticação e controle de acesso para AWS CodeCommit](auth-and-access-control.md)
+ [Como AWS CodeCommit funciona com o IAM](security_iam_service-with-iam.md)
+ [CodeCommit políticas baseadas em recursos](#security_iam_service-with-iam-resource-based-policies)
+ [Autorização baseada em CodeCommit tags](#security_iam_service-with-iam-tags)
+ [CodeCommit Funções do IAM](#security_iam_service-with-iam-roles)
+ [AWS CodeCommit exemplos de políticas baseadas em identidade](#security_iam_id-based-policy-examples)
+ [Solução de problemas AWS CodeCommit de identidade e acesso](#security_iam_troubleshoot)
## Público
A forma como você usa AWS Identity and Access Management (IAM) difere com base na sua função:
+ **Usuário do serviço**: solicite permissões ao seu administrador se você não conseguir acessar os atributos (consulte [Solução de problemas AWS CodeCommit de identidade e acesso](#security_iam_troubleshoot)).
+ **Administrador do serviço**: determine o acesso do usuário e envie solicitações de permissão (consulte [Como AWS CodeCommit funciona com o IAM](security_iam_service-with-iam.md))
+ **Administrador do IAM**: escreva políticas para gerenciar o acesso (consulte [AWS CodeCommit exemplos de políticas baseadas em identidade](#security_iam_id-based-policy-examples))
## Autenticação com identidades
A autenticação é a forma como você faz login AWS usando suas credenciais de identidade. Você deve estar autenticado como usuário do IAM ou assumindo uma função do IAM. Usuário raiz da conta da AWS
Você pode fazer login como uma identidade federada usando credenciais de uma fonte de identidade como Centro de Identidade do AWS IAM (IAM Identity Center), autenticação de login único ou credenciais. Google/Facebook Para ter mais informações sobre como fazer login, consulte [Como fazer login em sua Conta da AWS](https://docs.aws.amazon.com/signin/latest/userguide/how-to-sign-in.html) no *Guia do usuário do Início de Sessão da AWS *.
Para acesso programático, AWS fornece um SDK e uma CLI para assinar solicitações criptograficamente. Para ter mais informações, consulte [AWS Signature Version 4 para solicitações de API](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html) no *Guia do usuário do IAM*.
### Conta da AWS usuário root
Ao criar um Conta da AWS, você começa com uma identidade de login chamada *usuário Conta da AWS raiz* que tem acesso completo a todos Serviços da AWS os recursos. É altamente recomendável não usar o usuário-raiz em tarefas diárias. Consulte as tarefas que exigem credenciais de usuário-raiz em [Tarefas que exigem credenciais de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks) no *Guia do usuário do IAM*.
### Usuários e grupos do IAM
Um *[usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html)* é uma identidade com permissões específicas para uma única pessoa ou aplicação. É recomendável usar credenciais temporárias, em vez de usuários do IAM com credenciais de longo prazo. Para obter mais informações, consulte [Exigir que usuários humanos usem a federação com um provedor de identidade para acessar AWS usando credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) no *Guia do usuário do IAM*.
Um [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html) especifica um conjunto de usuários do IAM e facilita o gerenciamento de permissões para grandes conjuntos de usuários. Para ter mais informações, consulte [Casos de uso de usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/gs-identities-iam-users.html) no *Guia do usuário do IAM*.
### Perfis do IAM
Uma *[perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* é uma identidade com permissões específicas que oferece credenciais temporárias. Você pode assumir uma função [mudando de um usuário para uma função do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) ou chamando uma operação de AWS API AWS CLI ou. Para saber mais, consulte [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) no *Manual do usuário do IAM*.
Os perfis do IAM são úteis para acesso de usuário federado, permissões de usuário do IAM temporárias, acesso entre contas, acesso entre serviços e aplicações em execução no Amazon EC2. Consulte mais informações em [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.
## Gerenciar o acesso usando políticas
Você controla o acesso AWS criando políticas e anexando-as a AWS identidades ou recursos. Uma política define permissões quando associada a uma identidade ou recurso. AWS avalia essas políticas quando um diretor faz uma solicitação. A maioria das políticas é armazenada AWS como documentos JSON. Para ter mais informações sobre documentos de política JSON, consulte [Visão geral das políticas JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json) no *Guia do usuário do IAM*.
Por meio de políticas, os administradores especificam quem tem acesso a que, definindo qual **entidade principal** pode realizar **ações** em quais **recursos** e sob quais **condições**.
Por padrão, usuários e perfis não têm permissões. Um administrador do IAM cria políticas do IAM e as adiciona aos perfis, os quais os usuários podem então assumir. As políticas do IAM definem permissões, independentemente do método usado para realizar a operação.
### Políticas baseadas em identidade
As políticas baseadas em identidade são documentos de políticas de permissão JSON que você anexa a uma identidade (usuário, grupo ou perfil). Essas políticas controlam quais ações as identidades podem realizar, em quais recursos e sob quais condições. Para saber como criar uma política baseada em identidade, consulte [Definir permissões personalizadas do IAM com as políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) no *Guia do Usuário do IAM*.
As políticas baseadas em identidade podem ser políticas *em linha* (incorporadas diretamente em uma única identidade) ou *políticas gerenciadas* (políticas autônomas anexadas a várias identidades). Para saber como escolher entre uma política gerenciada e políticas em linha, consulte [Escolher entre políticas gerenciadas e políticas em linha](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-choosing-managed-or-inline.html) no *Guia do usuário do IAM*.
### Políticas baseadas em recursos
Políticas baseadas em recursos são documentos de políticas JSON que você anexa a um recurso. Entre os exemplos estão *políticas de confiança de perfil* do IAM e *políticas de bucket* do Amazon S3. Em serviços compatíveis com políticas baseadas em recursos, os administradores de serviço podem usá-las para controlar o acesso a um recurso específico. É necessário [especificar uma entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html) em uma política baseada em recursos.
Políticas baseadas em recursos são políticas em linha localizadas nesse serviço. Você não pode usar políticas AWS gerenciadas do IAM em uma política baseada em recursos.
### Listas de controle de acesso (ACLs)
As listas de controle de acesso (ACLs) controlam quais diretores (membros da conta, usuários ou funções) têm permissões para acessar um recurso. ACLs são semelhantes às políticas baseadas em recursos, embora não usem o formato de documento de política JSON.
O Amazon S3 e o AWS WAF Amazon VPC são exemplos de serviços que oferecem suporte. ACLs Para saber mais ACLs, consulte a [visão geral da lista de controle de acesso (ACL)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html) no *Guia do desenvolvedor do Amazon Simple Storage Service*.
### Outros tipos de política
AWS oferece suporte a tipos de políticas adicionais que podem definir o máximo de permissões concedidas por tipos de políticas mais comuns:
+ **Limites de permissões**: definem o número máximo de permissões que uma política baseada em identidade pode conceder a uma entidade do IAM. Para saber mais sobre limites de permissões, consulte [Limites de permissões para identidades do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html) no *Guia do usuário do IAM*.
+ **Políticas de controle de serviço (SCPs)** — Especifique as permissões máximas para uma organização ou unidade organizacional em AWS Organizations. Para saber mais, consulte [Políticas de controle de serviço](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) no *Guia do usuário do AWS Organizations *.
+ **Políticas de controle de recursos (RCPs)** — Defina o máximo de permissões disponíveis para recursos em suas contas. Para obter mais informações, consulte [Políticas de controle de recursos (RCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) no *Guia AWS Organizations do usuário*.
+ **Políticas de sessão**: políticas avançadas transmitidas como um parâmetro durante a criação de uma sessão temporária para um perfil ou um usuário federado. Para saber mais, consulte [Políticas de sessão](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session) no *Guia do usuário do IAM*.
### Vários tipos de política
Quando vários tipos de política são aplicáveis a uma solicitação, é mais complicado compreender as permissões resultantes. Para saber como AWS determinar se uma solicitação deve ser permitida quando vários tipos de políticas estão envolvidos, consulte [Lógica de avaliação de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) no *Guia do usuário do IAM*.
# Autenticação e controle de acesso para AWS CodeCommit
O acesso a AWS CodeCommit requer credenciais. Essas credenciais devem ter permissões para acessar AWS recursos, como CodeCommit repositórios, e seu usuário do IAM, que você usa para gerenciar suas credenciais do Git ou a chave pública SSH que você usa para fazer conexões do Git. As seções a seguir fornecem detalhes sobre como você pode usar o [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) e como ajudar CodeCommit a proteger o acesso aos seus recursos:
+ [Autenticação](#authentication)
+ [Controle de acesso](#access-control)
## Autenticação
Como CodeCommit os repositórios são baseados em Git e oferecem suporte à funcionalidade básica do Git, incluindo credenciais do Git, recomendamos que você use um usuário do IAM ao trabalhar com. CodeCommit Você pode acessar CodeCommit com outros tipos de identidade, mas os outros tipos de identidade estão sujeitos a limitações, conforme descrito abaixo.
Tipos de identidade:
+ **Usuário do IAM**: um [usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html) é uma identidade na sua conta da Amazon Web Services com permissões personalizadas específicas. Por exemplo, um usuário do IAM pode ter permissões para criar e gerenciar credenciais do Git para acessar repositórios. CodeCommit **Esse é o tipo de usuário recomendado para trabalhar com CodeCommit.** Você pode usar um nome de usuário e senha do IAM para entrar em AWS páginas da Web seguras [Console de gerenciamento da AWS](https://console.aws.amazon.com/), como os [fóruns de AWS discussão](https://forums.aws.amazon.com/) ou o [AWS Support Centro](https://console.aws.amazon.com/support/home#/).
É possível gerar credenciais do Git ou associar chaves públicas SSH com seu usuário do IAM, ou ainda instalar e configurar o **git-remote-codecommit**. Essas são as maneiras mais fáceis de configurar o Git para trabalhar com seus CodeCommit repositórios. Com as [credenciais do Git](setting-up-gc.md), você gera um nome de usuário e senha estáticos no IAM. Essas credenciais são usadas para conexões HTTP com o Git e qualquer outra ferramenta de terceiros com suporte para a autenticação usando o nome de usuário e a senha do Git. Com conexões SSH, você cria arquivos de chave pública e privada em sua máquina local que o Git CodeCommit usa para autenticação SSH. Você associa a chave pública com o usuário do IAM e armazena a chave privada no computador local. O **[git-remote-codecommit](setting-up-git-remote-codecommit.md)** estende o próprio Git e não requer a configuração das credenciais do Git para o usuário.
Além disso, você pode gerar [chaves de acesso](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) para cada usuário. Use as teclas de acesso ao acessar AWS serviços de forma programática, seja por meio [de um dos AWS SDKs](https://aws.amazon.com/tools/) ou usando o [AWS Command Line Interface ()AWS CLI](https://aws.amazon.com/cli/). As ferramentas de SDK e de CLI usam as chaves de acesso para o cadastramento criptográfico das suas solicitações. Se você não usa as AWS ferramentas, você mesmo deve assinar as solicitações. CodeCommit suporta o *Signature Version 4*, um protocolo para autenticar solicitações de API de entrada. Para obter mais informações sobre a autenticação de solicitações, consulte [Processo de cadastramento do Signature versão 4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) na *Referência geral da AWS*.
+ **Usuário raiz da conta Amazon Web Services** — Ao se cadastrar AWS, você fornece um endereço de e-mail e uma senha associados à sua conta da Amazon Web Services. Estas são suas *credenciais raiz* e elas fornecem acesso total a todos os seus recursos da AWS . Alguns CodeCommit recursos não estão disponíveis para usuários da conta root. Além disso, a única maneira de usar o Git com sua conta root é instalar e configurar **git-remote-codecommit** (recomendado) ou configurar o auxiliar de AWS credenciais, que está incluído no. AWS CLI Você não pode usar as credenciais do Git ou os pares de chaves público/privada SSH com o usuário da sua conta raiz. Por esses motivos, não recomendamos usar o usuário da conta root ao interagir com CodeCommit.
**Importante**
Por motivos de segurança, recomendamos que você use as credenciais raiz para criar somente um *usuário administrador*, que é um *usuário do IAM* com permissões totais à sua conta da AWS . Em seguida, você pode usar esse usuário administrador para criar outros usuários e funções IAM com permissões limitadas. Para mais informações, consulte [Melhores práticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users) e [Criar um grupo e um usuário administrador](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) no *Guia do usuário do IAM*.
+ **IAM Identity Center e usuários no IAM Identity Center** — Centro de Identidade do AWS IAM expande os recursos de AWS Identity and Access Management fornecer um local central que reúne a administração dos usuários e seu acesso aos Contas da AWS aplicativos em nuvem. Embora seja recomendado para a maioria dos usuários que trabalham com a AWS, o IAM Identity Center não fornece mecanismos para credenciais do Git ou pares de chaves SSH. Esses usuários podem instalar e configurar CodeCommit repositórios **git-remote-codecommit** para clonar localmente, mas nem todos os ambientes de desenvolvimento integrados (IDEs) suportam clonagem, envio ou extração. **git-remote-codecommit**
Como prática recomendada, exija que os usuários humanos usem a federação com um provedor de identidade para acessar Serviços da AWS usando credenciais temporárias.
Uma *identidade federada* é um usuário do seu diretório corporativo, provedor de identidade da web ou Directory Service que acessa Serviços da AWS usando credenciais de uma fonte de identidade. As identidades federadas assumem funções que oferecem credenciais temporárias.
Para o gerenciamento de acesso centralizado, recomendamos Centro de Identidade do AWS IAM. Para saber mais, consulte [O que é o IAM Identity Center?](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
+ **Perfil do IAM**: como um usuário do IAM;, um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) é uma identidade do IAM que você pode criar na sua conta para conceder permissões específicas.
Uma *[perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)* é uma identidade com permissões específicas que oferece credenciais temporárias. Você pode assumir uma função [mudando de um usuário para uma função do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) ou chamando uma operação de AWS API AWS CLI ou. Para saber mais, consulte [Métodos para assumir um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage-assume.html) no *Manual do usuário do IAM*.
Os perfis do IAM são úteis para acesso de usuário federado, permissões de usuário do IAM temporárias, acesso entre contas, acesso entre serviços e aplicações em execução no Amazon EC2. Consulte mais informações em [Acesso a recursos entre contas no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies-cross-account-resource-access.html) no *Guia do usuário do IAM*.
**nota**
Você não pode usar as credenciais do Git ou pares de chaves pública/privada SSH com usuários federados. Além disso, preferências do usuário não estão disponíveis para usuários federados. Para obter informações sobre como configurar conexões usando acesso federado, consulte [Etapas de configuração para conexões HTTPS AWS CodeCommit com git-remote-codecommit](setting-up-git-remote-codecommit.md).
## Controle de acesso
Você pode ter credenciais válidas para autenticar suas solicitações, mas, a menos que tenha permissões, não poderá criar ou acessar CodeCommit recursos. Por exemplo, você deve ter permissões para visualizar repositórios, enviar código por push, criar e gerenciar credenciais do Git e assim por diante.
As seções a seguir descrevem como gerenciar permissões para CodeCommit. Recomendamos que você leia a visão geral primeiro.
+ [Visão geral do gerenciamento de permissões de acesso aos seus CodeCommit recursos](#auth-and-access-control-iam-access-control-identity-based)
+ [Usando políticas baseadas em identidade (políticas do IAM) para CodeCommit](auth-and-access-control-iam-identity-based-access-control.md)
+ [CodeCommit referência de permissões](auth-and-access-control-permissions-reference.md)
## Visão geral do gerenciamento de permissões de acesso aos seus CodeCommit recursos
Cada AWS recurso é de propriedade de uma conta da Amazon Web Services. As permissões para criar ou acessar um recurso são regidas por políticas de permissões. Um administrador de conta pode anexar políticas de permissões a identidades do IAM (ou seja, usuários, grupos e funções). Alguns serviços, como AWS Lambda, também oferecem suporte à anexação de políticas de permissões aos recursos.
**nota**
Um *administrador da conta* (ou usuário administrador) é um usuário com privilégios de administrador. Para obter mais informações, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
Ao conceder permissões, você decide quem recebe as permissões, os recursos relacionados às permissões concedidas e as ações específicas que deseja permitir nesses recursos.
**Topics**
+ [CodeCommit recursos e operações](#arn-formats)
+ [Informações sobre propriedade de recursos](#understanding-resource-ownership)
+ [Gerenciar acesso aos recursos da](#managing-access-resources)
+ [Escopo de recursos em CodeCommit](#resource-scoping)
+ [Especificação de elementos de política: recursos, ações, efeitos e entidades de segurança](#actions-effects-principals)
+ [Especificar condições em uma política](#policy-conditions)
### CodeCommit recursos e operações
Em CodeCommit, o recurso principal é um repositório. Cada recurso possui um nome de recurso da Amazon (ARN) exclusivo associado. Em uma política, você usa um Nome de recurso da Amazon (ARN) para identificar o recurso a que a política se aplica. Para obter mais informações sobre ARNs, consulte [Amazon Resource Names (ARN) e AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) no. *Referência geral da Amazon Web Services* CodeCommit atualmente não oferece suporte a outros tipos de recursos, chamados de sub-recursos.
A tabela a seguir descreve como especificar CodeCommit recursos.
| Tipo de recurso | Formato do ARN |
| --- | --- |
| Repositório | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| Todos os CodeCommit repositórios | arn:aws:codecommit:\$1 |
| Todos os CodeCommit repositórios pertencentes à conta especificada na conta especificada Região da AWS | arn: aws:codecommit::: \$1 *region* *account-id* |
**nota**
A maioria dos AWS serviços trata dois pontos (:) ou uma barra invertida (/) ARNs como o mesmo caractere. No entanto, CodeCommit requer uma correspondência exata nos padrões e regras dos recursos. Ao criar padrões de eventos, certifique-se de usar os caracteres corretos do ARN para que eles correspondam à sintaxe de ARN no recurso.
Por exemplo, é possível indicar um repositório específico (*MyDemoRepo*) em sua instrução usando o ARN dele da seguinte maneira:
```
"Resource": "arn:aws:codecommit:us-west-2:111111111111:MyDemoRepo"
```
Para especificar todos os repositórios que pertencem a uma conta específica, use o caractere curinga (\$1) da seguinte maneira:
```
"Resource": "arn:aws:codecommit:us-west-2:111111111111:*"
```
Para especificar todos os recursos, ou se uma ação de API específica não for compatível ARNs, use o caractere curinga (\$1) no `Resource` elemento da seguinte forma:
```
"Resource": "*"
```
Você também pode usar o caractere curinga (\$1) para especificar todos os recursos que correspondem à parte de um nome de repositório. Por exemplo, o seguinte ARN especifica qualquer CodeCommit repositório que comece com o nome `MyDemo` e esteja registrado na conta da Amazon Web Services no: `111111111111` `us-east-2` Região da AWS
```
arn:aws:codecommit:us-east-2:111111111111:MyDemo*
```
Para obter uma lista das operações disponíveis que funcionam com os CodeCommit recursos, consulte[CodeCommit referência de permissões](auth-and-access-control-permissions-reference.md).
### Informações sobre propriedade de recursos
A conta da Amazon Web Services tem os recursos criados na conta, independentemente de quem os criou. Mais especificamente, o proprietário do recurso é a conta da Amazon Web Services da [entidade principal](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html) (isto é, a conta raiz, um usuário do IAM ou um perfil do IAM) que autentica a solicitação de criação de recursos. Os seguintes exemplos mostram como isso funciona:
+ Se você criar um usuário do IAM em sua conta da Amazon Web Services e conceder permissões para criar CodeCommit recursos para esse usuário, o usuário poderá criar CodeCommit recursos. No entanto, sua conta da Amazon Web Services, à qual o usuário pertence, é proprietária dos CodeCommit recursos.
+ Se você usar as credenciais da conta raiz da sua conta da Amazon Web Services para criar uma regra, sua conta da Amazon Web Services é a proprietária do CodeCommit recurso.
+ Se você criar uma função do IAM em sua conta da Amazon Web Services com permissões para criar CodeCommit recursos, qualquer pessoa que possa assumir a função poderá criar CodeCommit recursos. Sua conta da Amazon Web Services, à qual a função pertence, é proprietária dos CodeCommit recursos.
### Gerenciar acesso aos recursos da
Para gerenciar o acesso aos AWS recursos, você usa políticas de permissões. Uma *política de permissões* descreve quem tem acesso a quê. A seção a seguir explica as opções para criar políticas de permissões.
**nota**
Esta seção discute o uso do IAM no contexto de CodeCommit. Não são fornecidas informações detalhadas sobre o serviço IAM. Para obter mais informações sobre o IAM, consulte [O que é o IAM?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) no *Guia do usuário do IAM*. Para obter informações sobre a sintaxe e as descrições da política do IAM, consulte a [referência da política do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) no *Manual do usuário do IAM*.
Políticas de permissões que são anexadas a uma identidade do IAM são chamadas de políticas baseadas em identidade (políticas do IAM). As políticas de permissões anexadas a um recurso são chamadas de políticas baseadas em recursos. Atualmente, CodeCommit oferece suporte somente a políticas baseadas em identidade (políticas do IAM).
**Topics**
+ [Políticas baseadas em identidade (políticas do IAM)](#identity-based-policies)
+ [Políticas baseadas em recursos](#resource-based-policies-overview)
#### Políticas baseadas em identidade (políticas do IAM)
Para gerenciar o acesso aos AWS recursos, você anexa políticas de permissões às identidades do IAM. Em CodeCommit, você usa políticas baseadas em identidade para controlar o acesso aos repositórios. Por exemplo, você pode fazer o seguinte:
+ **Anexe uma política de permissões a um usuário ou grupo em sua conta** — Para conceder a um usuário permissões para visualizar CodeCommit recursos no CodeCommit console, anexe uma política de permissões baseada em identidade a um usuário ou grupo ao qual o usuário pertença.
+ **Anexe uma política de permissões a um perfil (para conceder permissões entre contas)**: a delegação, como quando você quer conceder acesso entre contas, envolve estabelecer uma confiança entre a conta que possui o recurso (a conta confiante) e a conta que contém os usuários que precisam acessar o recurso (a conta confiável). Uma política de permissões concede ao usuário de um perfil as permissões necessárias para realizar as tarefas pretendidas no recurso. Uma política de confiança especifica quais contas confiáveis podem conceder a seus usuários permissões para assumir a função. Para obter mais informações, consulte [Termos e conceitos do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html).
Para conceder permissões entre contas, anexe uma política de permissões baseada em identidade para um perfil do IAM. Por exemplo, o administrador na Conta A pode criar uma função para conceder permissões entre contas a outra conta da Amazon Web Services (por exemplo, Conta B) ou a um AWS serviço da seguinte forma:
1. Um administrador da Conta A cria uma função do IAM e anexa uma política de permissões à função que concede permissões em recursos da Conta A.
1. Um administrador da Conta A anexa uma política de confiança à função identificando a Conta B como a entidade principal, que pode assumir a função.
1. O administrador da Conta B pode então delegar permissões para assumir a função a qualquer usuário na Conta B. Isso permite que os usuários da Conta B criem ou acessem recursos na Conta A. Se você quiser conceder a um AWS serviço permissão para assumir a função, o principal na política de confiança também pode ser um diretor de AWS serviço. Para obter mais informações, consulte Delegação, em [Termos e conceitos do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html).
Para obter mais informações sobre o uso do IAM para delegar permissões, consulte [Gerenciamento de acesso](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) no *Guia do usuário do IAM*.
A política de exemplo a seguir permite que um usuário crie uma ramificação em um repositório chamado *MyDemoRepo*:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codecommit:CreateBranch"
],
"Resource" : "arn:aws:codecommit:us-east-2:111122223333:MyDemoRepo"
}
]
}
```
------
Para restringir as chamadas e os recursos aos quais os usuários da sua conta têm acesso, crie políticas do IAM específicas e, em seguida, anexe essas políticas a usuários do IAM. Para obter mais informações sobre como criar funções do IAM e explorar exemplos de declarações de política do IAM para CodeCommit, consulte[Exemplos de políticas de identidade gerenciadas pelo cliente](customer-managed-policies.md#customer-managed-policies-identity).
#### Políticas baseadas em recursos
Alguns serviços, como o Amazon S3, também suportam políticas de permissões baseadas em recursos. Por exemplo, você pode anexar uma política baseada em recursos a um bucket do S3 para gerenciar as permissões de acesso a esse bucket. CodeCommit não oferece suporte a políticas baseadas em recursos, mas você pode usar tags para identificar recursos, que podem ser usados nas políticas do IAM. Para obter um exemplo de uma política baseada em tags, consulte [Políticas baseadas em identidade (políticas do IAM)](#identity-based-policies).
### Escopo de recursos em CodeCommit
Em CodeCommit, você pode definir o escopo de políticas e permissões baseadas em identidade para recursos, conforme descrito em. [CodeCommit recursos e operações](#arn-formats) No entanto, você não pode definir o escopo da permissão `ListRepositories` para um recurso. Em vez disso, você deve definir o escopo para todos os recursos (usando o curinga `*`). Caso contrário, a ação falhará.
Todas as outras CodeCommit permissões podem ser atribuídas aos recursos.
### Especificação de elementos de política: recursos, ações, efeitos e entidades de segurança
Você pode criar políticas para permitir ou negar aos usuários o acesso aos recursos, ou permitir ou negar que os usuários realizem ações específicas nesses recursos. CodeCommit define um conjunto de operações públicas de API que definem como os usuários trabalham com o serviço, seja por meio do CodeCommit console SDKs, do AWS CLI, do ou chamando-os diretamente APIs. Para conceder permissões para essas operações de API, CodeCommit defina um conjunto de ações que você pode especificar em uma política.
Algumas operações de API podem exigir permissões para mais de uma ação. Para obter mais informações sobre os recursos e operações da API, consulte [CodeCommit recursos e operações](#arn-formats) e [CodeCommit referência de permissões](auth-and-access-control-permissions-reference.md).
Estes são os elementos básicos de uma política:
+ **Recurso**: para identificar o recurso ao qual a política se aplica, você usa um nome do recurso da Amazon (ARN). Para obter mais informações, consulte [CodeCommit recursos e operações](#arn-formats).
+ **Ação**: para identificar operações de recursos que deseja permitir ou negar, use palavras-chave de ação. Por exemplo, dependendo do especificado`Effect`, a `codecommit:GetBranch` permissão permite ou nega que o usuário execute a `GetBranch` operação, que obtém detalhes sobre uma ramificação em um CodeCommit repositório.
+ **Efeito**: você especifica o efeito, permitir ou negar, que ocorre quando o usuário solicita a ação específica. Se você não conceder (permitir) explicitamente acesso a um recurso, o acesso estará implicitamente negado. Você também pode negar explicitamente o acesso a um recurso, para ter a certeza de que um usuário não consiga acessá-lo, mesmo que uma política diferente conceda acesso.
+ **Principal** — Nas políticas baseadas em identidade (políticas do IAM), o único tipo de política CodeCommit compatível, o usuário ao qual a política está vinculada é o principal implícito.
Para saber mais sobre a sintaxe da política do IAM, consulte a [Referência da política do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html) no *Guia do usuário do IAM*.
Para ver uma tabela mostrando todas as ações da CodeCommit API e os recursos aos quais elas se aplicam, consulte[CodeCommit referência de permissões](auth-and-access-control-permissions-reference.md).
### Especificar condições em uma política
Ao conceder permissões, você usa a linguagem de políticas de acesso do IAM para especificar as condições em que uma política deve entrar em vigor. Por exemplo, é recomendável aplicar uma política somente após uma data específica. Para obter mais informações sobre como especificar condições em uma linguagem de política, consulte [Condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition) e [Gramática de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_grammar.html) no *Guia do usuário do IAM*.
Para expressar condições, você usa chaves de condição predefinidas. Não existem chaves de condição específicas do CodeCommit. No entanto, existem chaves AWS de condição abrangentes que você pode usar conforme apropriado. Para obter uma lista completa AWS de chaves abrangentes, consulte [Chaves disponíveis para condições](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys) no *Guia do usuário do IAM*.
# Usando políticas baseadas em identidade (políticas do IAM) para CodeCommit
Os exemplos a seguir de políticas baseadas em identidade demonstram como um administrador de conta pode anexar políticas de permissões às identidades do IAM (usuários, grupos e funções) para conceder permissões para realizar operações em recursos. CodeCommit
**Importante**
Recomendamos que você primeiro analise os tópicos introdutórios que explicam os conceitos básicos e as opções disponíveis para gerenciar o acesso aos seus CodeCommit recursos. Para obter mais informações, consulte [Visão geral do gerenciamento de permissões de acesso aos seus CodeCommit recursos](auth-and-access-control.md#auth-and-access-control-iam-access-control-identity-based).
**Topics**
+ [Permissões necessárias para usar o CodeCommit console](#console-permissions)
+ [Visualizar recursos no console](#console-resources)
+ [AWS políticas gerenciadas para CodeCommit](security-iam-awsmanpol.md)
+ [Exemplos de política gerenciada pelo cliente](customer-managed-policies.md)
O seguinte é um exemplo de uma política de permissões com base em identidade:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codecommit:BatchGetRepositories"
],
"Resource" : [
"arn:aws:codecommit:us-east-2:111122223333:MyDemoRepo",
"arn:aws:codecommit:us-east-2:111122223333:MyDemo*"
]
}
]
}
```
------
Essa política tem uma declaração que permite ao usuário obter informações sobre o CodeCommit repositório nomeado `MyDestinationRepo` e todos os CodeCommit repositórios que começam com o nome `MyDemo` na Região. **us-east-2**
## Permissões necessárias para usar o CodeCommit console
Para ver as permissões necessárias para cada operação de CodeCommit API e para obter mais informações sobre CodeCommit operações, consulte[CodeCommit referência de permissões](auth-and-access-control-permissions-reference.md).
Para permitir que os usuários usem o CodeCommit console, o administrador deve conceder a eles permissões para CodeCommit ações. Por exemplo, você pode anexar a política [AWSCodeCommitPowerUser](security-iam-awsmanpol.md#managed-policies-poweruser)gerenciada ou equivalente a um usuário ou grupo.
Além das permissões concedidas aos usuários por políticas baseadas em identidade, CodeCommit requer permissões para ações AWS Key Management Service (AWS KMS). Um usuário do IAM não precisa de permissões `Allow` explícitas para essas ações, mas não deve ter uma política anexada que defina as seguintes permissões como `Deny`:
```
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt",
"kms:GenerateDataKey",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:DescribeKey"
```
Para obter mais informações sobre criptografia e CodeCommit, consulte[AWS KMS e criptografia](encryption.md).
## Visualizar recursos no console
O CodeCommit console exige a `ListRepositories` permissão para exibir uma lista de repositórios para sua conta da Amazon Web Services no Região da AWS local em que você está conectado. O console também inclui uma função **Go to resource (Acessar recurso)** para realizar uma pesquisa por recursos que diferencia letras maiúsculas de minúsculas. Essa pesquisa é realizada na sua conta da Amazon Web Services no Região da AWS local em que você está conectado. Os seguintes recursos são exibidos nos seguintes serviços:
+ AWS CodeBuild: projetos de compilação
+ AWS CodeCommit: repositórios
+ AWS CodeDeploy: aplicativos
+ AWS CodePipeline: pipelines
Para realizar essa pesquisa nos recursos em todos os serviços, você deve ter as seguintes permissões:
+ CodeBuild: `ListProjects`
+ CodeCommit: `ListRepositories`
+ CodeDeploy: `ListApplications`
+ CodePipeline: `ListPipelines`
Os resultados não serão retornados para os recursos de um serviço se você não tiver permissões para esse serviço. Mesmo se você tiver permissões para visualizar recursos, recursos específicos não serão retornados se houver um `Deny` explícito para visualizar esses recursos.
# AWS políticas gerenciadas para CodeCommit
Para adicionar permissões a usuários, grupos e funções, é mais fácil usar políticas AWS gerenciadas do que escrever políticas você mesmo. É necessário tempo e experiência para criar [políticas gerenciadas pelo cliente do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html) que fornecem à sua equipe apenas as permissões de que precisam. Para começar rapidamente, você pode usar nossas políticas AWS gerenciadas. Essas políticas abrangem casos de uso comuns e estão disponíveis na sua Conta da AWS. Para obter mais informações sobre políticas AWS gerenciadas, consulte [políticas AWS gerenciadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*.
AWS os serviços mantêm e atualizam as políticas AWS gerenciadas. Você não pode alterar as permissões nas políticas AWS gerenciadas. Os serviços ocasionalmente acrescentam permissões adicionais a uma política gerenciada pela AWS para oferecer suporte a novos recursos. Esse tipo de atualização afeta todas as identidades (usuários, grupos e funções) em que a política está anexada. É mais provável que os serviços atualizem uma política gerenciada pela AWS quando um novo recurso for iniciado ou novas operações se tornarem disponíveis. Os serviços não removem as permissões de uma política AWS gerenciada, portanto, as atualizações de políticas não violarão suas permissões existentes.
Além disso, AWS oferece suporte a políticas gerenciadas para funções de trabalho que abrangem vários serviços. Por exemplo, a política **ReadOnlyAccess** AWS gerenciada fornece acesso somente de leitura a todos os AWS serviços e recursos. Quando um serviço lança um novo recurso, AWS adiciona permissões somente de leitura para novas operações e recursos. Para obter uma lista e descrições das políticas de perfis de trabalho, consulte [Políticas gerenciadas pela AWS para perfis de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
AWS aborda muitos casos de uso comuns fornecendo políticas autônomas do IAM que são criadas e administradas pela AWS. Essas políticas AWS gerenciadas concedem as permissões necessárias para casos de uso comuns. As políticas gerenciadas CodeCommit também fornecem permissões para realizar operações em outros serviços, como IAM, Amazon SNS e Amazon CloudWatch Events, conforme exigido pelas responsabilidades dos usuários que receberam a política em questão. Por exemplo, a AWSCode CommitFullAccess política é uma política de usuário de nível administrativo que permite aos usuários com essa política criar e gerenciar regras de CloudWatch eventos para repositórios (regras cujos nomes são prefixados com) e tópicos do `codecommit` Amazon SNS para notificações sobre eventos relacionados ao repositório (tópicos cujos nomes são prefixados com), bem como administrar repositórios em. `codecommit` CodeCommit
As políticas AWS gerenciadas a seguir, que você pode anexar aos usuários em sua conta, são específicas de CodeCommit.
**Topics**
+ [AWS política gerenciada: AWSCode CommitFullAccess](#managed-policies-full)
+ [AWS política gerenciada: AWSCode CommitPowerUser](#managed-policies-poweruser)
+ [AWS política gerenciada: AWSCode CommitReadOnly](#managed-policies-read)
+ [CodeCommit políticas e notificações gerenciadas](#notifications-permissions)
+ [AWS CodeCommit políticas gerenciadas e Amazon CodeGuru Reviewer](#codeguru-permissions)
+ [CodeCommit atualizações nas políticas AWS gerenciadas](#security-iam-awsmanpol-updates)
## AWS política gerenciada: AWSCode CommitFullAccess
É possível anexar a política `AWSCodeCommitFullAccess` às suas identidades do IAM. Esta política concede acesso total CodeCommit a. Aplique essa política somente aos usuários de nível administrativo aos quais você deseja conceder controle total sobre CodeCommit repositórios e recursos relacionados em sua conta da Amazon Web Services, incluindo a capacidade de excluir repositórios.
A AWSCode CommitFullAccess política contém a seguinte declaração de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:*"
],
"Resource": "*"
},
{
"Sid": "CloudWatchEventsCodeCommitRulesAccess",
"Effect": "Allow",
"Action": [
"events:DeleteRule",
"events:DescribeRule",
"events:DisableRule",
"events:EnableRule",
"events:PutRule",
"events:PutTargets",
"events:RemoveTargets",
"events:ListTargetsByRule"
],
"Resource": "arn:aws:events:*:*:rule/codecommit*"
},
{
"Sid": "SNSTopicAndSubscriptionAccess",
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:DeleteTopic",
"sns:Subscribe",
"sns:Unsubscribe",
"sns:SetTopicAttributes"
],
"Resource": "arn:aws:sns:*:*:codecommit*"
},
{
"Sid": "SNSTopicAndSubscriptionReadAccess",
"Effect": "Allow",
"Action": [
"sns:ListTopics",
"sns:ListSubscriptionsByTopic",
"sns:GetTopicAttributes"
],
"Resource": "*"
},
{
"Sid": "LambdaReadOnlyListAccess",
"Effect": "Allow",
"Action": [
"lambda:ListFunctions"
],
"Resource": "*"
},
{
"Sid": "IAMReadOnlyListAccess",
"Effect": "Allow",
"Action": [
"iam:ListUsers"
],
"Resource": "*"
},
{
"Sid": "IAMReadOnlyConsoleAccess",
"Effect": "Allow",
"Action": [
"iam:ListAccessKeys",
"iam:ListSSHPublicKeys",
"iam:ListServiceSpecificCredentials"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "IAMUserSSHKeys",
"Effect": "Allow",
"Action": [
"iam:DeleteSSHPublicKey",
"iam:GetSSHPublicKey",
"iam:ListSSHPublicKeys",
"iam:UpdateSSHPublicKey",
"iam:UploadSSHPublicKey"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "IAMSelfManageServiceSpecificCredentials",
"Effect": "Allow",
"Action": [
"iam:CreateServiceSpecificCredential",
"iam:UpdateServiceSpecificCredential",
"iam:DeleteServiceSpecificCredential",
"iam:ResetServiceSpecificCredential"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "CodeStarNotificationsReadWriteAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:DeleteNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe"
],
"Resource": "*",
"Condition": {
"ArnLike": {
"codestar-notifications:NotificationsForResource": "arn:aws:iam::*:role/Service*"
}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource",
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
},
{
"Sid": "CodeStarNotificationsSNSTopicCreateAccess",
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:SetTopicAttributes"
],
"Resource": "arn:aws:sns:*:*:codestar-notifications*"
},
{
"Sid": "AmazonCodeGuruReviewerFullAccess",
"Effect": "Allow",
"Action": [
"codeguru-reviewer:AssociateRepository",
"codeguru-reviewer:DescribeRepositoryAssociation",
"codeguru-reviewer:ListRepositoryAssociations",
"codeguru-reviewer:DisassociateRepository",
"codeguru-reviewer:DescribeCodeReview",
"codeguru-reviewer:ListCodeReviews"
],
"Resource": "*"
},
{
"Sid": "AmazonCodeGuruReviewerSLRCreation",
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/codeguru-reviewer.amazonaws.com/AWSServiceRoleForAmazonCodeGuruReviewer",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "codeguru-reviewer.amazonaws.com"
}
}
},
{
"Sid": "CloudWatchEventsManagedRules",
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:PutTargets",
"events:DeleteRule",
"events:RemoveTargets"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"events:ManagedBy": "codeguru-reviewer.amazonaws.com"
}
}
},
{
"Sid": "CodeStarNotificationsChatbotAccess",
"Effect": "Allow",
"Action": [
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:ListMicrosoftTeamsChannelConfigurations"
],
"Resource": "*"
},
{
"Sid": "CodeStarConnectionsReadOnlyAccess",
"Effect": "Allow",
"Action": [
"codestar-connections:ListConnections",
"codestar-connections:GetConnection"
],
"Resource": "arn:aws:codestar-connections:*:*:connection/*"
}
]
}
```
------
## AWS política gerenciada: AWSCode CommitPowerUser
É possível anexar a política `AWSCodeCommitPowerUser` às suas identidades do IAM. Essa política permite que os usuários acessem todas as funcionalidades CodeCommit e recursos relacionados ao repositório, exceto que não permite que eles excluam CodeCommit repositórios nem criem ou excluam recursos relacionados ao repositório em outros serviços AWS , como o Amazon Events. CloudWatch Recomendamos que você aplique essa política à maioria dos usuários.
A AWSCode CommitPowerUser política contém a seguinte declaração de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:AssociateApprovalRuleTemplateWithRepository",
"codecommit:BatchAssociateApprovalRuleTemplateWithRepositories",
"codecommit:BatchDisassociateApprovalRuleTemplateFromRepositories",
"codecommit:BatchGet*",
"codecommit:BatchDescribe*",
"codecommit:Create*",
"codecommit:DeleteBranch",
"codecommit:DeleteFile",
"codecommit:Describe*",
"codecommit:DisassociateApprovalRuleTemplateFromRepository",
"codecommit:EvaluatePullRequestApprovalRules",
"codecommit:Get*",
"codecommit:List*",
"codecommit:Merge*",
"codecommit:OverridePullRequestApprovalRules",
"codecommit:Put*",
"codecommit:Post*",
"codecommit:TagResource",
"codecommit:Test*",
"codecommit:UntagResource",
"codecommit:Update*",
"codecommit:GitPull",
"codecommit:GitPush"
],
"Resource": "*"
},
{
"Sid": "CloudWatchEventsCodeCommitRulesAccess",
"Effect": "Allow",
"Action": [
"events:DeleteRule",
"events:DescribeRule",
"events:DisableRule",
"events:EnableRule",
"events:PutRule",
"events:PutTargets",
"events:RemoveTargets",
"events:ListTargetsByRule"
],
"Resource": "arn:aws:events:*:*:rule/codecommit*"
},
{
"Sid": "SNSTopicAndSubscriptionAccess",
"Effect": "Allow",
"Action": [
"sns:Subscribe",
"sns:Unsubscribe"
],
"Resource": "arn:aws:sns:*:*:codecommit*"
},
{
"Sid": "SNSTopicAndSubscriptionReadAccess",
"Effect": "Allow",
"Action": [
"sns:ListTopics",
"sns:ListSubscriptionsByTopic",
"sns:GetTopicAttributes"
],
"Resource": "*"
},
{
"Sid": "LambdaReadOnlyListAccess",
"Effect": "Allow",
"Action": [
"lambda:ListFunctions"
],
"Resource": "*"
},
{
"Sid": "IAMReadOnlyListAccess",
"Effect": "Allow",
"Action": [
"iam:ListUsers"
],
"Resource": "*"
},
{
"Sid": "IAMReadOnlyConsoleAccess",
"Effect": "Allow",
"Action": [
"iam:ListAccessKeys",
"iam:ListSSHPublicKeys",
"iam:ListServiceSpecificCredentials"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "IAMUserSSHKeys",
"Effect": "Allow",
"Action": [
"iam:DeleteSSHPublicKey",
"iam:GetSSHPublicKey",
"iam:ListSSHPublicKeys",
"iam:UpdateSSHPublicKey",
"iam:UploadSSHPublicKey"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "IAMSelfManageServiceSpecificCredentials",
"Effect": "Allow",
"Action": [
"iam:CreateServiceSpecificCredential",
"iam:UpdateServiceSpecificCredential",
"iam:DeleteServiceSpecificCredential",
"iam:ResetServiceSpecificCredential"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "CodeStarNotificationsReadWriteAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe"
],
"Resource": "*",
"Condition": {
"ArnLike": {
"codestar-notifications:NotificationsForResource": "arn:aws:iam::*:role/Service*"
}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource",
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
},
{
"Sid": "AmazonCodeGuruReviewerFullAccess",
"Effect": "Allow",
"Action": [
"codeguru-reviewer:AssociateRepository",
"codeguru-reviewer:DescribeRepositoryAssociation",
"codeguru-reviewer:ListRepositoryAssociations",
"codeguru-reviewer:DisassociateRepository",
"codeguru-reviewer:DescribeCodeReview",
"codeguru-reviewer:ListCodeReviews"
],
"Resource": "*"
},
{
"Sid": "AmazonCodeGuruReviewerSLRCreation",
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/codeguru-reviewer.amazonaws.com/AWSServiceRoleForAmazonCodeGuruReviewer",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "codeguru-reviewer.amazonaws.com"
}
}
},
{
"Sid": "CloudWatchEventsManagedRules",
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:PutTargets",
"events:DeleteRule",
"events:RemoveTargets"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"events:ManagedBy": "codeguru-reviewer.amazonaws.com"
}
}
},
{
"Sid": "CodeStarNotificationsChatbotAccess",
"Effect": "Allow",
"Action": [
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:ListMicrosoftTeamsChannelConfigurations"
],
"Resource": "*"
},
{
"Sid": "CodeStarConnectionsReadOnlyAccess",
"Effect": "Allow",
"Action": [
"codestar-connections:ListConnections",
"codestar-connections:GetConnection"
],
"Resource": "arn:aws:codestar-connections:*:*:connection/*"
}
]
}
```
------
## AWS política gerenciada: AWSCode CommitReadOnly
É possível anexar a política `AWSCodeCommitReadOnly` às suas identidades do IAM. Essa política concede acesso somente para leitura CodeCommit e recursos relacionados ao repositório em outros AWS serviços, bem como a capacidade de criar e gerenciar seus próprios recursos CodeCommit relacionados (como credenciais Git e chaves SSH para o usuário do IAM usar ao acessar repositórios). Aplique essa política aos usuários a quem você deseja conceder a capacidade de ler o conteúdo de um repositório, mas não de fazer alterações a seus conteúdos.
A AWSCode CommitReadOnly política contém a seguinte declaração de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"codecommit:BatchGet*",
"codecommit:BatchDescribe*",
"codecommit:Describe*",
"codecommit:EvaluatePullRequestApprovalRules",
"codecommit:Get*",
"codecommit:List*",
"codecommit:GitPull"
],
"Resource":"*"
},
{
"Sid":"CloudWatchEventsCodeCommitRulesReadOnlyAccess",
"Effect":"Allow",
"Action":[
"events:DescribeRule",
"events:ListTargetsByRule"
],
"Resource":"arn:aws:events:*:*:rule/codecommit*"
},
{
"Sid":"SNSSubscriptionAccess",
"Effect":"Allow",
"Action":[
"sns:ListTopics",
"sns:ListSubscriptionsByTopic",
"sns:GetTopicAttributes"
],
"Resource":"*"
},
{
"Sid":"LambdaReadOnlyListAccess",
"Effect":"Allow",
"Action":[
"lambda:ListFunctions"
],
"Resource":"*"
},
{
"Sid":"IAMReadOnlyListAccess",
"Effect":"Allow",
"Action":[
"iam:ListUsers"
],
"Resource":"*"
},
{
"Sid":"IAMReadOnlyConsoleAccess",
"Effect":"Allow",
"Action":[
"iam:ListAccessKeys",
"iam:ListSSHPublicKeys",
"iam:ListServiceSpecificCredentials",
"iam:GetSSHPublicKey"
],
"Resource":"arn:aws:iam::*:user/${aws:username}"
},
{
"Sid":"CodeStarNotificationsReadOnlyAccess",
"Effect":"Allow",
"Action":[
"codestar-notifications:DescribeNotificationRule"
],
"Resource":"*",
"Condition":{
"ArnLike":{
"codestar-notifications:NotificationsForResource":"arn:aws:codecommit:us-east-2:111122223333:*"
}
}
},
{
"Sid":"CodeStarNotificationsListAccess",
"Effect":"Allow",
"Action":[
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListEventTypes",
"codestar-notifications:ListTargets"
],
"Resource":"*"
},
{
"Sid": "AmazonCodeGuruReviewerReadOnlyAccess",
"Effect": "Allow",
"Action": [
"codeguru-reviewer:DescribeRepositoryAssociation",
"codeguru-reviewer:ListRepositoryAssociations",
"codeguru-reviewer:DescribeCodeReview",
"codeguru-reviewer:ListCodeReviews"
],
"Resource": "*"
},
{
"Sid": "CodeStarConnectionsReadOnlyAccess",
"Effect": "Allow",
"Action": [
"codestar-connections:ListConnections",
"codestar-connections:GetConnection"
],
"Resource": "arn:aws:codestar-connections:*:*:connection/*"
}
]
}
```
------
## CodeCommit políticas e notificações gerenciadas
AWS CodeCommit suporta notificações, que podem notificar os usuários sobre mudanças importantes nos repositórios. Políticas gerenciadas para CodeCommit incluir declarações de política para funcionalidade de notificação. Para obter mais informações, consulte [O que são notificações?](https://docs.aws.amazon.com/codestar-notifications/latest/userguide/welcome.html).
### Permissões relacionadas a notificações em políticas gerenciadas de acesso total
A política gerenciada `AWSCodeCommitFullAccess` inclui as declarações a seguir para permitir acesso total às notificações. Os usuários com essa política gerenciada aplicada também podem criar e gerenciar tópicos do Amazon SNS para notificações, assinar e cancelar a assinatura de usuários dos tópicos, listar tópicos a serem escolhidos como destinos para regras de notificação e listar clientes do Amazon Q Developer configurados no Slack.
```
{
"Sid": "CodeStarNotificationsReadWriteAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:DeleteNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws:codecommit:*"}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource,"
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
},
{
"Sid": "CodeStarNotificationsSNSTopicCreateAccess",
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:SetTopicAttributes"
],
"Resource": "arn:aws:sns:*:*:codestar-notifications*"
},
{
"Sid": "CodeStarNotificationsChatbotAccess",
"Effect": "Allow",
"Action": [
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:ListMicrosoftTeamsChannelConfigurations"
],
"Resource": "*"
}
```
### Permissões relacionadas a notificações em políticas gerenciadas somente leitura
A política gerenciada `AWSCodeCommitReadOnlyAccess` inclui as instruções a seguir para permitir acesso somente leitura às notificações. Os usuários com essa política gerenciada aplicada podem visualizar notificações de recursos, mas não podem criá-los, gerenciá-los ou assiná-los.
```
{
"Sid": "CodeStarNotificationsPowerUserAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:DescribeNotificationRule"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws:codecommit:*"}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListEventTypes",
"codestar-notifications:ListTargets"
],
"Resource": "*"
}
```
### Permissões relacionadas a notificações em outras políticas gerenciadas
A política gerenciada `AWSCodeCommitPowerUser` inclui as instruções a seguir para permitir que os usuários criem, editem e assinem notificações. Os usuários não podem excluir regras de notificação nem gerenciar tags de recursos.
```
{
"Sid": "CodeStarNotificationsReadWriteAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:DeleteNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws:codecommit*"}
}
},
{
"Sid": "CodeStarNotificationsListAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource",
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
},
{
"Sid": "SNSTopicListAccess",
"Effect": "Allow",
"Action": [
"sns:ListTopics"
],
"Resource": "*"
},
{
"Sid": "CodeStarNotificationsChatbotAccess",
"Effect": "Allow",
"Action": [
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:ListMicrosoftTeamsChannelConfigurations"
],
"Resource": "*"
}
```
Para obter mais informações sobre o IAM e as notificações, consulte [Identity and Access Management para Notificações do AWS CodeStar](https://docs.aws.amazon.com/codestar-notifications/latest/userguide/security-iam.html).
## AWS CodeCommit políticas gerenciadas e Amazon CodeGuru Reviewer
CodeCommit oferece suporte ao Amazon CodeGuru Reviewer, um serviço automatizado de revisão de código que usa análise de programas e aprendizado de máquina para detectar problemas comuns e recomendar correções em seu código Java ou Python. Políticas gerenciadas para CodeCommit incluir declarações de política para a funcionalidade CodeGuru Reviewer. Para obter mais informações, consulte [O que é o Amazon CodeGuru Reviewer](https://docs.aws.amazon.com/codeguru/latest/reviewer-ug/welcome.html).
### Permissões relacionadas ao CodeGuru revisor em AWSCode CommitFullAccess
A política `AWSCodeCommitFullAccess` gerenciada inclui as seguintes declarações para permitir que o CodeGuru revisor seja associado e desassociado CodeCommit dos repositórios. Os usuários com essa política gerenciada aplicada também podem visualizar o status da associação entre os CodeCommit repositórios e o CodeGuru Reviewer e visualizar o status dos trabalhos de revisão para pull requests.
```
{
"Sid": "AmazonCodeGuruReviewerFullAccess",
"Effect": "Allow",
"Action": [
"codeguru-reviewer:AssociateRepository",
"codeguru-reviewer:DescribeRepositoryAssociation",
"codeguru-reviewer:ListRepositoryAssociations",
"codeguru-reviewer:DisassociateRepository",
"codeguru-reviewer:DescribeCodeReview",
"codeguru-reviewer:ListCodeReviews"
],
"Resource": "*"
},
{
"Sid": "AmazonCodeGuruReviewerSLRCreation",
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/codeguru-reviewer.amazonaws.com/AWSServiceRoleForAmazonCodeGuruReviewer",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "codeguru-reviewer.amazonaws.com"
}
}
},
{
"Sid": "CloudWatchEventsManagedRules",
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:PutTargets",
"events:DeleteRule",
"events:RemoveTargets"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"events:ManagedBy": "codeguru-reviewer.amazonaws.com"
}
}
}
```
### Permissões relacionadas ao CodeGuru revisor em AWSCode CommitPowerUser
A política `AWSCodeCommitPowerUser` gerenciada inclui as seguintes declarações para permitir que os usuários associem e desassociem repositórios com o CodeGuru Reviewer, visualizem o status da associação e visualizem o status dos trabalhos de revisão para pull requests.
```
{
"Sid": "AmazonCodeGuruReviewerFullAccess",
"Effect": "Allow",
"Action": [
"codeguru-reviewer:AssociateRepository",
"codeguru-reviewer:DescribeRepositoryAssociation",
"codeguru-reviewer:ListRepositoryAssociations",
"codeguru-reviewer:DisassociateRepository",
"codeguru-reviewer:DescribeCodeReview",
"codeguru-reviewer:ListCodeReviews"
],
"Resource": "*"
},
{
"Sid": "AmazonCodeGuruReviewerSLRCreation",
"Action": "iam:CreateServiceLinkedRole",
"Effect": "Allow",
"Resource": "arn:aws:iam::*:role/aws-service-role/codeguru-reviewer.amazonaws.com/AWSServiceRoleForAmazonCodeGuruReviewer",
"Condition": {
"StringLike": {
"iam:AWSServiceName": "codeguru-reviewer.amazonaws.com"
}
}
},
{
"Sid": "CloudWatchEventsManagedRules",
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:PutTargets",
"events:DeleteRule",
"events:RemoveTargets"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"events:ManagedBy": "codeguru-reviewer.amazonaws.com"
}
}
}
```
### Permissões relacionadas ao CodeGuru revisor em AWSCode CommitReadOnly
A política `AWSCodeCommitReadOnlyAccess` gerenciada inclui as seguintes declarações para permitir acesso somente para leitura ao status da associação de CodeGuru revisores e visualizar o status dos trabalhos de revisão para pull requests. Os usuários com essa política gerenciada aplicada não podem associar ou desassociar repositórios.
```
{
"Sid": "AmazonCodeGuruReviewerReadOnlyAccess",
"Effect": "Allow",
"Action": [
"codeguru-reviewer:DescribeRepositoryAssociation",
"codeguru-reviewer:ListRepositoryAssociations",
"codeguru-reviewer:DescribeCodeReview",
"codeguru-reviewer:ListCodeReviews"
],
"Resource": "*"
}
```
### Função vinculada ao serviço Amazon CodeGuru Reviewer
Quando você associa um repositório ao CodeGuru Reviewer, uma função vinculada ao serviço é criada para que o CodeGuru Reviewer possa detectar problemas e recomendar correções para o código Java ou Python em pull requests. A função vinculada ao serviço é chamada de AWSServiceRoleForAmazonCodeGuruReviewer. Para obter mais informações, consulte [Usando funções vinculadas ao serviço para o Amazon CodeGuru Reviewer](https://docs.aws.amazon.com/codeguru/latest/reviewer-ug/using-service-linked-roles.html).
Para obter mais informações, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*.
## CodeCommit atualizações nas políticas AWS gerenciadas
Veja detalhes sobre as atualizações das políticas AWS gerenciadas CodeCommit desde que esse serviço começou a rastrear essas alterações. Para obter alertas automáticos sobre alterações feitas nesta página, assine o feed RSS em [AWS CodeCommit Histórico do documento do Guia do Usuário](history.md).
| Alteração | Descrição | Data |
| --- | --- | --- |
| [AWS política gerenciada: AWSCode CommitFullAccess](#managed-policies-full) e [AWS política gerenciada: AWSCode CommitPowerUser](#managed-policies-poweruser): atualização em políticas existentes | CodeCommit adicionou uma permissão a essas políticas para oferecer suporte a um tipo adicional de notificação usando o Amazon Q Developer em aplicativos de bate-papo. As AWSCode CommitFullAccess políticas AWSCode CommitPowerUser e foram alteradas para adicionar uma permissão,`chatbot:ListMicrosoftTeamsChannelConfigurations`. | 16 de maio de 2023 |
| [AWS política gerenciada: AWSCode CommitReadOnly](#managed-policies-read) – atualização para uma política existente | CodeCommit removeu uma permissão duplicada da política. AWSCodeCommitReadOnly Foi alterado para remover uma permissão duplicada,`"iam:ListAccessKeys"`. | 18 de agosto de 2021 |
| CodeCommit começou a rastrear alterações | CodeCommit começou a rastrear as mudanças em suas políticas AWS gerenciadas. | 18 de agosto de 2021 |
# Exemplos de política gerenciada pelo cliente
Você pode criar suas próprias políticas personalizadas do IAM para permitir permissões para CodeCommit ações e recursos. Você pode anexar essas políticas personalizadas a usuários ou grupos do IAM que exijam essas permissões. Você também pode criar suas próprias políticas personalizadas de IAM para integração CodeCommit entre outros AWS serviços.
**Topics**
+ [Exemplos de políticas de identidade gerenciadas pelo cliente](#customer-managed-policies-identity)
## Exemplos de políticas de identidade gerenciadas pelo cliente
O exemplo a seguir de políticas do IAM concede permissões para várias CodeCommit ações. Use-os para limitar o CodeCommit acesso de seus usuários e funções do IAM. Essas políticas controlam a capacidade de realizar ações com o CodeCommit console AWS SDKs, a API ou AWS CLI o.
**nota**
Todos os exemplos usam a região Oeste dos EUA (Oregon) (us-west-2) e contêm uma conta fictícia. IDs
**Exemplos**
+ [Exemplo 1: Permitir que um usuário realize CodeCommit operações em uma única Região da AWS](#identity-based-policies-example-1)
+ [Exemplo 2: permitir que um usuário use o Git para um único repositório](#identity-based-policies-example-2)
+ [Exemplo 3: permitir que um usuário conectado a partir de um intervalo de endereços IP especificado acesse um repositório](#identity-based-policies-example-3)
+ [Exemplo 4: negar ou permitir ações em ramificações](#identity-based-policies-example-4)
+ [Exemplo 5: negar ou permitir ações em repositórios com tags](#identity-based-policies-example-5)
### Exemplo 1: Permitir que um usuário realize CodeCommit operações em uma única Região da AWS
A política de permissões a seguir usa um caractere curinga (`"codecommit:*"`) para permitir que os usuários realizem todas as CodeCommit ações na região us-east-2 e não em outra. Regiões da AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "codecommit:*",
"Resource": "arn:aws:codecommit:us-east-2:111111111111:*",
"Condition": {
"StringEquals": {
"aws:RequestedRegion": "us-east-2"
}
}
},
{
"Effect": "Allow",
"Action": "codecommit:ListRepositories",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestedRegion": "us-east-2"
}
}
}
]
}
```
------
### Exemplo 2: permitir que um usuário use o Git para um único repositório
Em CodeCommit, as permissões da política `GitPull` do IAM se aplicam a qualquer comando do cliente Git do qual os dados são recuperados CodeCommit, incluindo **git fetch****git clone**, e assim por diante. Da mesma forma, as permissões da política `GitPush` do IAM se aplicam a qualquer comando do cliente Git para o qual os dados são enviados. CodeCommit Por exemplo, se a permissão da política `GitPush` do IAM estiver definida como `Allow`, um usuário poderá enviar via push a exclusão de uma ramificação usando o protocolo Git. Esse envio via push não é afetado por qualquer permissão aplicada à operação `DeleteBranch` para esse usuário do IAM. A `DeleteBranch` permissão se aplica às ações realizadas com o console, o AWS CLI SDKs, o e a API, mas não com o protocolo Git.
O exemplo a seguir permite que o usuário especificado extraia e envie para o CodeCommit repositório chamado`MyDemoRepo`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codecommit:GitPull",
"codecommit:GitPush"
],
"Resource" : "arn:aws:codecommit:us-east-2:111122223333:MyDemoRepo"
}
]
}
```
------
### Exemplo 3: permitir que um usuário conectado a partir de um intervalo de endereços IP especificado acesse um repositório
Você pode criar uma política que só permite que os usuários se conectem a um repositório do CodeCommit se o endereço IP deles estiver dentro de determinado intervalo de endereços IP. Existem duas abordagens igualmente válidas para isso. Você pode criar uma `Deny` política que CodeCommit proíba operações se o endereço IP do usuário não estiver dentro de um bloco específico ou criar uma `Allow` política que permita CodeCommit operações se o endereço IP do usuário estiver dentro de um bloco específico.
Você pode criar uma política `Deny` que nega o acesso a todos os usuários que não estão dentro de um determinado intervalo de IPs. Por exemplo, você pode anexar a política gerenciada AWSCodeCommitPowerUser e uma política gerenciada pelo cliente a todos os usuários que necessitam de acesso ao seu repositório. O exemplo de política a seguir nega todas as CodeCommit permissões aos usuários cujos endereços IP não estejam dentro do bloco de endereços IP especificado de 203.0.113.0/16:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"codecommit:*"
],
"Resource": "*",
"Condition": {
"NotIpAddress": {
"aws:SourceIp": [
"203.0.113.0/16"
]
}
}
}
]
}
```
------
O exemplo de política a seguir permite que o usuário especificado acesse um CodeCommit repositório nomeado MyDemoRepo com as permissões equivalentes da política AWSCode CommitPowerUser gerenciada somente se o endereço IP estiver dentro do bloco de endereços especificado de 203.0.113.0/16:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:BatchGetRepositories",
"codecommit:CreateBranch",
"codecommit:CreateRepository",
"codecommit:Get*",
"codecommit:GitPull",
"codecommit:GitPush",
"codecommit:List*",
"codecommit:Put*",
"codecommit:Post*",
"codecommit:Merge*",
"codecommit:TagResource",
"codecommit:Test*",
"codecommit:UntagResource",
"codecommit:Update*"
],
"Resource": "arn:aws:codecommit:us-east-2:111122223333:MyDemoRepo",
"Condition": {
"IpAddress": {
"aws:SourceIp": [
"203.0.113.0/16"
]
}
}
}
]
}
```
------
### Exemplo 4: negar ou permitir ações em ramificações
Você pode criar uma política que nega aos usuários permissões para as ações que você especificar em uma ou mais ramificações. Como alternativa, você pode criar uma política que permita ações em uma ou mais ramificações que, de outra forma, elas não teriam em outras ramificações de um repositório. Você pode usar essas políticas com as políticas gerenciadas adequadas (predefinidas). Para obter mais informações, consulte [Limite os envios e fusões às ramificações em AWS CodeCommit](how-to-conditional-branch.md).
Por exemplo, você pode criar uma `Deny` política que negue aos usuários a capacidade de fazer alterações em uma ramificação chamada main, incluindo a exclusão dessa ramificação, em um repositório chamado. *MyDemoRepo* Você pode usar essa política com a política gerenciada **AWSCodeCommitPowerUser**. Os usuários com essas duas políticas aplicadas poderiam criar e excluir ramificações, criar pull requests e todas as outras ações conforme permitido **AWSCodeCommitPowerUser**, mas não conseguiriam enviar alterações para a ramificação chamada *main*, adicionar ou editar um arquivo na ramificação *principal* no CodeCommit console ou mesclar ramificações ou uma pull request na ramificação *principal*. Como `Deny` é aplicado ao `GitPush`, você deve incluir uma instrução `Null` à política para permitir que as chamadas `GitPush` iniciais sejam analisadas para validação quando os usuários fizerem envios por push de seus repositórios locais.
**dica**
Se desejar criar uma política que se aplica a todas as ramificações chamadas *master* em todos os repositórios da sua conta da Amazon Web Services, em `Resource`, especifique um asterisco ( `*` ) em vez de um ARN de repositório.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"codecommit:GitPush",
"codecommit:DeleteBranch",
"codecommit:PutFile",
"codecommit:Merge*"
],
"Resource": "arn:aws:codecommit:us-east-2:111111111111:MyDemoRepo",
"Condition": {
"StringEqualsIfExists": {
"codecommit:References": [
"refs/heads/main"
]
},
"Null": {
"codecommit:References": "false"
}
}
}
]
}
```
------
O exemplo de política a seguir permite ao usuário fazer alterações em uma ramificação chamada master em todos os repositórios de uma conta da Amazon Web Services. Ele não permitirá alterações em nenhuma outra ramificação. Você pode usar essa política com a política AWSCode CommitReadOnly gerenciada para permitir envios automatizados para o repositório na ramificação principal. Como o efeito é `Allow`, este exemplo de política não funciona com políticas gerenciadas, como a AWSCodeCommitPowerUser.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPush",
"codecommit:Merge*"
],
"Resource": "*",
"Condition": {
"StringEqualsIfExists": {
"codecommit:References": [
"refs/heads/main"
]
}
}
}
]
}
```
------
### Exemplo 5: negar ou permitir ações em repositórios com tags
Você pode criar uma política que permita ou negue ações em repositórios com base nas AWS tags associadas a esses repositórios e, em seguida, aplicar essas políticas aos grupos do IAM que você configura para gerenciar usuários do IAM. Por exemplo, você pode criar uma política que negue todas as CodeCommit ações em qualquer repositório com a AWS tag *Status* da chave e o valor da chave *Secret* e, em seguida, aplicar essa política ao grupo do IAM que você criou para desenvolvedores gerais ()*Developers*. Em seguida, você precisa garantir que os desenvolvedores que trabalham nesses repositórios marcados não sejam membros desse *Developers* grupo geral, mas pertençam a um grupo diferente do IAM que não tenha a política restritiva aplicada () *SecretDevelopers*.
*O exemplo a seguir nega todas as CodeCommit ações em repositórios marcados com o *status* da chave e o valor da chave Secret:*
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"codecommit:Associate*",
"codecommit:Batch*",
"codecommit:CancelUploadArchive",
"codecommit:CreateBranch",
"codecommit:CreateCommit",
"codecommit:CreatePullRequest*",
"codecommit:CreateRepository",
"codecommit:CreateUnreferencedMergeCommit",
"codecommit:DeleteBranch",
"codecommit:DeleteCommentContent",
"codecommit:DeleteFile",
"codecommit:DeletePullRequest*",
"codecommit:DeleteRepository",
"codecommit:Describe*",
"codecommit:DisassociateApprovalRuleTemplateFromRepository",
"codecommit:EvaluatePullRequestApprovalRules",
"codecommit:GetBlob",
"codecommit:GetBranch",
"codecommit:GetComment*",
"codecommit:GetCommit",
"codecommit:GetDifferences*",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:GetMerge*",
"codecommit:GetObjectIdentifier",
"codecommit:GetPullRequest*",
"codecommit:GetReferences",
"codecommit:GetRepository*",
"codecommit:GetTree",
"codecommit:GetUploadArchiveStatus",
"codecommit:Git*",
"codecommit:ListAssociatedApprovalRuleTemplatesForRepository",
"codecommit:ListBranches",
"codecommit:ListPullRequests",
"codecommit:ListTagsForResource",
"codecommit:Merge*",
"codecommit:OverridePullRequestApprovalRules",
"codecommit:Post*",
"codecommit:Put*",
"codecommit:TagResource",
"codecommit:TestRepositoryTriggers",
"codecommit:UntagResource",
"codecommit:UpdateComment",
"codecommit:UpdateDefaultBranch",
"codecommit:UpdatePullRequest*",
"codecommit:UpdateRepository*",
"codecommit:UploadArchive"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Status": "Secret"
}
}
}
]
}
```
------
Você pode refinar ainda mais essa estratégia, fornecendo repositórios específicos, em vez de todos os repositórios, como recursos. Você também pode criar políticas que permitam CodeCommit ações em todos os repositórios que não estejam marcados com tags específicas. Por exemplo, a política a seguir permite o equivalente a **AWSCodeCommitPowerUser**permissões para CodeCommit ações, exceto que ela só permite CodeCommit ações em repositórios não marcados com as tags especificadas:
**nota**
Este exemplo de política inclui somente ações para CodeCommit. Ela não inclui ações para outros AWS serviços incluídos na política **AWSCodeCommitPowerUser**gerenciada. Para obter mais informações, consulte [AWS política gerenciada: AWSCode CommitPowerUser](security-iam-awsmanpol.md#managed-policies-poweruser)..
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:Associate*",
"codecommit:Batch*",
"codecommit:CancelUploadArchive",
"codecommit:CreateBranch",
"codecommit:CreateCommit",
"codecommit:CreatePullRequest*",
"codecommit:CreateRepository",
"codecommit:CreateUnreferencedMergeCommit",
"codecommit:DeleteBranch",
"codecommit:DeleteCommentContent",
"codecommit:DeleteFile",
"codecommit:DeletePullRequest*",
"codecommit:Describe*",
"codecommit:DisassociateApprovalRuleTemplateFromRepository",
"codecommit:EvaluatePullRequestApprovalRules",
"codecommit:GetBlob",
"codecommit:GetBranch",
"codecommit:GetComment*",
"codecommit:GetCommit",
"codecommit:GetDifferences*",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:GetMerge*",
"codecommit:GetObjectIdentifier",
"codecommit:GetPullRequest*",
"codecommit:GetReferences",
"codecommit:GetRepository*",
"codecommit:GetTree",
"codecommit:GetUploadArchiveStatus",
"codecommit:Git*",
"codecommit:ListAssociatedApprovalRuleTemplatesForRepository",
"codecommit:ListBranches",
"codecommit:ListPullRequests",
"codecommit:ListTagsForResource",
"codecommit:Merge*",
"codecommit:OverridePullRequestApprovalRules",
"codecommit:Post*",
"codecommit:Put*",
"codecommit:TagResource",
"codecommit:TestRepositoryTriggers",
"codecommit:UntagResource",
"codecommit:UpdateComment",
"codecommit:UpdateDefaultBranch",
"codecommit:UpdatePullRequest*",
"codecommit:UpdateRepository*",
"codecommit:UploadArchive"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:ResourceTag/Status": "Secret",
"aws:ResourceTag/Team": "Saanvi"
}
}
},
{
"Effect": "Allow",
"Action": [
"codecommit:CreateApprovalRuleTemplate",
"codecommit:GetApprovalRuleTemplate",
"codecommit:ListApprovalRuleTemplates",
"codecommit:ListRepositories",
"codecommit:ListRepositoriesForApprovalRuleTemplate",
"codecommit:UpdateApprovalRuleTemplateContent",
"codecommit:UpdateApprovalRuleTemplateDescription",
"codecommit:UpdateApprovalRuleTemplateName"
],
"Resource": "*"
}
]
}
```
------
# CodeCommit referência de permissões
As tabelas a seguir listam cada operação de CodeCommit API, as ações correspondentes para as quais você pode conceder permissões e o formato do ARN do recurso a ser usado para conceder permissões. Eles CodeCommit APIs são agrupados em tabelas com base no escopo das ações permitidas por essa API. Consulte-as ao configurar o [Controle de acesso](auth-and-access-control.md#access-control) e gravar políticas de permissões que você pode anexar a uma identidade do IAM (políticas baseadas em identidade).
Quando você cria uma política de permissões, você especifica as ações no campo `Action` da política. Você especifica o valor do recurso no campo `Resource` da política como um ARN, com ou sem um caractere curinga (\$1).
Para expressar condições em suas CodeCommit políticas, use chaves AWS de condição abrangentes. Para obter uma lista completa AWS de chaves gerais, consulte [Chaves disponíveis](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#AvailableKeys) no *Guia do usuário do IAM*. Para obter informações completas sobre ações, recursos e chaves de condição CodeCommit nas políticas do IAM, consulte [Ações, recursos e chaves de condição para AWS CodeCommit](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscodecommit.html).
**nota**
Para especificar uma ação, use o `codecommit:` prefixo seguido do nome da operação da API (por exemplo, `codecommit:GetRepository` ou `codecommit:CreateRepository`).
**Usar curingas **
Para especificar várias ações ou recursos, use um caractere curinga (\$1) no seu ARN. Por exemplo, `codecommit:*` especifica todas as CodeCommit ações e `codecommit:Get*` especifica todas as CodeCommit ações que começam com a palavra. `Get` O exemplo a seguir concede acesso a todos os repositórios com nomes que começam com `MyDemo`.
```
arn:aws:codecommit:us-west-2:111111111111:MyDemo*
```
Você pode usar curingas somente com os *repository-name* recursos listados na tabela a seguir. Você não pode usar curingas com *region* ou *account-id* recursos. Para obter mais informações sobre curingas, consulte [Identificadores do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html), no *Guia do usuário do IAM*.
**Topics**
+ [Permissões necessárias para comandos do cliente Git](#aa-git)
+ [Permissões para ações em ramificações](#aa-branches)
+ [Permissões para ações em mesclagens](#aa-merges)
+ [Permissões para ações em solicitações pull](#aa-pr)
+ [Permissões para ações em modelos de regras de aprovação](#aa-art)
+ [Permissões para ações em arquivos individuais](#aa-files)
+ [Permissões para ações em comentários](#aa-comments)
+ [Permissões para ações no código confirmado](#aa-code)
+ [Permissões para ações em repositórios](#aa-repositories)
+ [Permissões para ações em tags](#aa-tags)
+ [Permissões para ações em acionadores](#aa-triggers)
+ [Permissões para ações na CodePipeline integração](#aa-acp)
## Permissões necessárias para comandos do cliente Git
Em CodeCommit, as permissões da política `GitPull` do IAM se aplicam a qualquer comando do cliente Git do qual os dados são recuperados CodeCommit, incluindo **git fetch****git clone**, e assim por diante. Da mesma forma, as permissões da política `GitPush` do IAM se aplicam a qualquer comando do cliente Git para o qual os dados são enviados. CodeCommit Por exemplo, se a permissão da política `GitPush` do IAM estiver definida como `Allow`, um usuário poderá enviar via push a exclusão de uma ramificação usando o protocolo Git. Esse envio via push não é afetado por qualquer permissão aplicada à operação `DeleteBranch` para esse usuário do IAM. A `DeleteBranch` permissão se aplica às ações realizadas com o console, o AWS CLI SDKs, o e a API, mas não com o protocolo Git.
`GitPull` e `GitPush` são permissões de política do IAM. Elas não são ações de API.
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Permissões necessárias para ações para comandos do cliente Git**
| CodeCommit Permissões para o Git | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| GitPull | `codecommit:GitPull` Necessário para extrair informações de um CodeCommit repositório para um repositório local. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| GitPush | `codecommit:GitPush` Obrigatório para enviar informações de um repositório local para um repositório do CodeCommit. Esta é apenas uma permissão de política do IAM, e não uma ação de API. Se você criar uma política que inclui uma chave de contexto e uma instrução `Deny` que inclui essa permissão, você também deve incluir um contexto `Null`. Para obter mais informações, consulte [Limite os envios e fusões às ramificações em AWS CodeCommit](how-to-conditional-branch.md). | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em ramificações
As permissões a seguir permitem ou negam ações em ramificações em CodeCommit repositórios. Essas permissões se referem somente às ações realizadas no CodeCommit console e com a CodeCommit API e aos comandos executados usando o. AWS CLI Elas não pertencem a ações semelhantes que podem ser realizadas usando o protocolo Git. Por exemplo, o comando **git show-branch -r** exibe uma lista de ramificações remotas para um repositório e suas confirmações usando o protocolo Git. Ele não é afetado por nenhuma permissão para a CodeCommit `ListBranches` operação.
Para obter mais informações sobre como criar políticas para ramificações, consulte [Limite os envios e fusões às ramificações em AWS CodeCommit](how-to-conditional-branch.md) e [Exemplos de política gerenciada pelo cliente](customer-managed-policies.md).
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em filiais**
| CodeCommit Operações de API para filiais | Permissões obrigatórias (ações de API): | Recursos |
| --- | --- | --- |
| [CreateBranch](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_CreateBranch.html) | `codecommit:CreateBranch` Necessário para criar uma ramificação em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [DeleteBranch](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DeleteBranch.html) | `codecommit:DeleteBranch` Necessário para excluir uma ramificação de um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetBranch](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetBranch.html) | `codecommit:GetBranch` Obrigatório para obter detalhes sobre uma ramificação em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [ListBranches](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_ListBranches.html) | `codecommit:ListBranches` Obrigatório para obter uma lista de ramificações em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [MergeBranchesByFastForward](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_MergeBranchesByFastForward.html) | `codecommit:MergeBranchesByFastForward` Necessário para mesclar duas ramificações usando a estratégia de mesclagem rápida em um repositório. CodeCommit | arn: aws:codecommit::: region account-id repository-name |
| [MergeBranchesBySquash](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_MergeBranchesBySquash.html) | `codecommit:MergeBranchesBySquash` Necessário para mesclar duas ramificações usando a estratégia de mesclagem de squash em um repositório. CodeCommit | arn: aws:codecommit::: region account-id repository-name |
| [MergeBranchesByThreeWay](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_MergeBranchesByThreeWay.html) | `codecommit:MergeBranchesByThreeWay` Necessário para mesclar duas ramificações usando a estratégia de mesclagem de três vias em um repositório. CodeCommit | arn: aws:codecommit::: region account-id repository-name |
| [UpdateDefaultBranch](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdateDefaultBranch.html) | codecommit:UpdateDefaultBranchNecessário para alterar a ramificação padrão em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em mesclagens
As permissões a seguir permitem ou negam ações em mesclagens em CodeCommit repositórios. Essas permissões dizem respeito às ações realizadas com o CodeCommit console e a CodeCommit API, e aos comandos executados usando o. AWS CLI Elas não pertencem a ações semelhantes que podem ser realizadas usando o protocolo Git. Para permissões relacionadas em ramificações, consulte [Permissões para ações em ramificações](#aa-branches). Para permissões relacionadas em solicitações pull, consulte [Permissões para ações em solicitações pull](#aa-pr).
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Permissões necessárias para ações de comandos de mesclagem**
| CodeCommit Permissões para mesclagens | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| [BatchDescribeMergeConflicts](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_BatchDescribeMergeConflicts.html) | `codecommit:BatchDescribeMergeConflicts` Obrigatório para retornar informações sobre conflitos em uma mesclagem entre commits em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [CreateUnreferencedMergeCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_CreateUnreferencedMergeCommit.html) | `codecommit:CreateUnreferencedMergeCommit` Necessário criar um commit não referenciado entre duas ramificações ou commits em um CodeCommit repositório com o objetivo de compará-los e identificar possíveis conflitos. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [DescribeMergeConflicts](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DescribeMergeConflicts.html) | `codecommit:DescribeMergeConflicts` Obrigatório para retornar informações sobre conflitos de mesclagem entre as versões base, de origem e de destino de um arquivo em uma possível mesclagem em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetMergeCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetMergeCommit.html) | `codecommit:GetMergeCommit` Obrigatório para retornar informações sobre a mesclagem entre um commit de origem e de destino em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetMergeOptions](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetMergeOptions.html) | `codecommit:GetMergeOptions` Obrigatório para retornar informações sobre as opções de mesclagem disponíveis entre dois especificadores de confirmação ou ramificações em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em solicitações pull
As seguintes permissões permitem ou negam ações em solicitações pull em repositórios do CodeCommit. Essas permissões dizem respeito às ações realizadas com o CodeCommit console e a CodeCommit API, e aos comandos executados usando o. AWS CLI Elas não pertencem a ações semelhantes que podem ser realizadas usando o protocolo Git. Para permissões relacionadas em comentários, consulte [Permissões para ações em comentários](#aa-comments).
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em pull requests**
| CodeCommit Operações de API | Permissões obrigatórias (ações de API) | Recursos |
| --- | --- | --- |
| BatchGetPullRequests | `codecommit:BatchGetPullRequests` Obrigatório para retornar informações sobre uma ou mais pull requests em um CodeCommit repositório. Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [CreatePullRequest](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_CreatePullRequest.html) | `codecommit:CreatePullRequest` Obrigatório para criar uma solicitação de extração em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [CreatePullRequestApprovalRule](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_CreatePullRequestApprovalRule.html) | `codecommit:CreatePullRequestApprovalRule` Obrigatório para criar uma regra de aprovação de uma solicitação pull em um repositório do CodeCommit . | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [DeletePullRequestApprovalRule](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DeletePullRequestApprovalRule.html) | `codecommit:DeletePullRequestApprovalRule` Obrigatório para excluir uma regra de aprovação de uma solicitação pull em um repositório do CodeCommit . | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [DescribePullRequestEvents](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DescribePullRequestEvents.html) | Obrigatório para retornar informações sobre um ou mais eventos de pull request em um CodeCommit repositório. | arn: aws:codecommit::: region account-id repository-name |
| [EvaluatePullRequestApprovalRules](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_EvaluatePullRequestApprovalRules.html) | `codecommit:EvaluatePullRequestApprovalRules` Obrigatório para avaliar se uma solicitação pull atendeu a todas as condições especificadas em suas regras de aprovação associadas em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetCommentsForPullRequest](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetCommentsForPullRequest.html) | `codecommit:GetCommentsForPullRequest` Obrigatório para retornar comentários feitos em uma solicitação pull. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| GetCommitsFromMergeBase | `codecommit:GetCommitsFromMergeBase` Obrigatório para retornar informações sobre a diferença entre confirmações no contexto de uma possível mesclagem. Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetMergeConflicts](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetMergeConflicts.html) | `codecommit:GetMergeConflicts` Obrigatório para retornar informações sobre conflitos de mesclagem entre as ramificações de origem e de destino em uma solicitação pull. | arn: aws:codecommit::: region account-id repository-name |
| [GetPullRequest](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetPullRequest.html) | `codecommit:GetPullRequest` Obrigatório para retornar informações sobre uma solicitação pull. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetPullRequestApprovalStates](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetPullRequestApprovalStates.html) | `codecommit:GetPullRequestApprovalStates` Obrigatório para retornar informações sobre os estados de aprovação de uma solicitação pull especificada. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetPullRequestOverrideState](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetPullRequestOverrideState.html) | `codecommit:GetPullRequestOverrideState` Obrigatório para retornar informações sobre se as regras de aprovação foram reservadas (substituídas) de uma solicitação pull. Em caso afirmativo, o nome do recurso da Amazon (ARN) do usuário ou identidade que substituiu as regras e seus requisitos da solicitação pull. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [ListPullRequests](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_ListPullRequests.html) | `codecommit:ListPullRequests` Obrigatório para retornar informações sobre as solicitações pull para um repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [MergePullRequestByFastForward](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_MergePullRequestByFastForward.html) | codecommit:MergePullRequestByFastForwardObrigatório para fechar uma solicitação pull e tentar mesclar a ramificação de origem com a ramificação de destino de uma solicitação pull usando a opção de mesclagem de avanço rápido. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [MergePullRequestBySquash](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_MergePullRequestBySquash.html) | codecommit:MergePullRequestBySquashObrigatório para fechar uma solicitação pull e tentar mesclar a ramificação de origem com a ramificação de destino de uma solicitação pull usando a estratégia de mesclagem de compressão. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [MergePullRequestByThreeWay](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_MergePullRequestByThreeWay.html) | codecommit:MergePullRequestByThreeWayObrigatório para fechar uma solicitação pull e tentar mesclar a ramificação de origem com a ramificação de destino de uma solicitação pull usando a estratégia de mesclagem de três vias. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [OverridePullRequestApprovalRules](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_OverridePullRequestApprovalRules.html) | codecommit:OverridePullRequestApprovalRules Obrigatório para deixar de lado todos os requisitos da regra de aprovação para uma pull request em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [PostCommentForPullRequest](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_PostCommentForPullRequest.html) | codecommit:PostCommentForPullRequest Obrigatório para publicar um comentário em uma solicitação de extração em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UpdatePullRequestApprovalRuleContent](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdatePullRequestApprovalRuleContent.html) | codecommit:UpdatePullRequestApprovalRuleContent Necessário para alterar a estrutura de uma regra de aprovação para uma pull request em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UpdatePullRequestApprovalState](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdatePullRequestApprovalState.html) | codecommit:UpdatePullRequestApprovalState Necessário para alterar o estado de uma aprovação em uma pull request em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UpdatePullRequestDescription](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdatePullRequestDescription.html) | codecommit:UpdatePullRequestDescription Obrigatório para alterar a descrição de uma solicitação de extração em um repositório do CodeCommit . | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UpdatePullRequestStatus](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdatePullRequestStatus.html) | codecommit:UpdatePullRequestStatus Obrigatório para alterar o status de uma solicitação de extração em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UpdatePullRequestTitle](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdatePullRequestTitle.html) | codecommit:UpdatePullRequestTitle Obrigatório para alterar o título de uma solicitação de extração em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em modelos de regras de aprovação
As permissões a seguir permitem ou negam ações em modelos de regras de aprovação em repositórios do CodeCommit . Essas permissões se referem somente às ações realizadas no CodeCommit console, na CodeCommit API e aos comandos executados usando o. AWS CLI Elas não pertencem a ações semelhantes que podem ser realizadas usando o protocolo Git. Para permissões relacionadas em solicitações pull, consulte [Permissões para ações em solicitações pull](#aa-pr).
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em modelos de regras de aprovação**
| CodeCommit Operações de API para modelos de regras de aprovação | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| [AssociateApprovalRuleTemplateWithRepository](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_AssociateApprovalRuleTemplateWithRepository.html) | `codecommit:AssociateApprovalRuleTemplateWithRepository` Obrigatório para associar um modelo a um repositório especificado em uma conta da Amazon Web Services. Depois da associação, isso cria automaticamente regras de aprovação que correspondem às condições do modelo em cada solicitação pull criada no repositório especificado. | \$1 |
| [BatchAssociateApprovalRuleTemplateWithRepositories](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_BatchAssociateApprovalRuleTemplateWithRepositories.html) | `codecommit:BatchAssociateApprovalRuleTemplateWithRepositories` Obrigatório para associar um modelo a um ou mais repositórios especificados em uma conta da Amazon Web Services. | \$1 |
| [BatchDisassociateApprovalRuleTemplateFromRepositories](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_BatchDisassociateApprovalRuleTemplateFromRepositories.html) | `codecommit:BatchDisassociateApprovalRuleTemplateFromRepositories` Obrigatório para desassociar um modelo de um ou mais repositórios especificados em uma conta da Amazon Web Services. | \$1 |
| [CreateApprovalRuleTemplate](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_CreateApprovalRuleTemplate.html) | `codecommit:CreateApprovalRuleTemplate` Obrigatório para criar um modelo para regras de aprovação que podem ser associadas a um ou mais repositórios em sua conta da AWS . | \$1 |
| [DeleteApprovalRuleTemplate](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DeleteApprovalRuleTemplate.html) | `codecommit:DeleteApprovalRuleTemplate` Obrigatório para excluir o modelo especificado em uma conta da Amazon Web Services. Ele não remove regras de aprovação em solicitações pull já criadas com o modelo. | \$1 |
| [DisassociateApprovalRuleTemplateFromRepository](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DisassociateApprovalRuleTemplateFromRepository.html) | `codecommit:DisassociateApprovalRuleTemplateFromRepository` Obrigatório para desassociar o modelo especificado de um repositório em uma conta da Amazon Web Services. Ele não remove regras de aprovação em solicitações pull já criadas com o modelo. | \$1 |
| [GetApprovalRuleTemplate](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetApprovalRuleTemplate.html) | `codecommit:GetApprovalRuleTemplate` Obrigatório para retornar informações sobre um modelo de regra de aprovação em uma conta da Amazon Web Services. | \$1 |
| [ListApprovalRuleTemplates](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_ListApprovalRuleTemplates.html) | `codecommit:ListApprovalRuleTemplates` Obrigatório para listar modelos de regras de aprovação em uma conta da Amazon Web Services. | \$1 |
| [ListAssociatedApprovalRuleTemplatesForRepository](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_ListAssociatedApprovalRuleTemplatesForRepository.html) | `codecommit:ListAssociatedApprovalRuleTemplatesForRepository` Obrigatório para listar todos os modelos de regras de aprovação associados a um repositório especificado em uma conta da Amazon Web Services. | \$1 |
| [ListRepositoriesForApprovalRuleTemplate](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_ListRepositoriesForApprovalRuleTemplate.html) | `codecommit:ListRepositoriesForApprovalRuleTemplate` Obrigatório para listar todos os repositórios associados a um modelo de regra de aprovação especificado em uma conta da Amazon Web Services. | \$1 |
| [UpdateApprovalRuleTemplateContent](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdateApprovalRuleTemplateContent.html) | `codecommit:UpdateApprovalRuleTemplateContent` Obrigatório para atualizar o conteúdo de um modelo de regra de aprovação em uma conta da Amazon Web Services. | \$1 |
| [UpdateApprovalRuleTemplateDescription](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdateApprovalRuleTemplateDescription.html) | `codecommit:UpdateApprovalRuleTemplateDescription` Obrigatório para atualizar a descrição de um modelo de regra de aprovação em uma conta da Amazon Web Services. | \$1 |
| [UpdateApprovalRuleTemplateName](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdateApprovalRuleTemplateName.html) | `codecommit:UpdateApprovalRuleTemplateName` Obrigatório para atualizar o nome de um modelo de regra de aprovação em uma conta da Amazon Web Services. | \$1 |
## Permissões para ações em arquivos individuais
As seguintes permissões permitem ou negam ações em arquivos individuais em repositórios do CodeCommit. Essas permissões se referem somente às ações realizadas no CodeCommit console, na CodeCommit API e aos comandos executados usando o. AWS CLI Elas não pertencem a ações semelhantes que podem ser realizadas usando o protocolo Git. Por exemplo, o comando `git push` envia arquivos novos e alterados para um repositório do CodeCommit usando o protocolo Git. Ele não é afetado por nenhuma permissão para a CodeCommit `PutFile` operação.
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em arquivos individuais**
| CodeCommit Operações de API para arquivos individuais | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| [DeleteFile](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DeleteFile.html) | `codecommit:DeleteFile` Necessário para excluir um arquivo especificado de uma ramificação especificada em um CodeCommit repositório a partir do CodeCommit console. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetBlob](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetBlob.html) | `codecommit:GetBlob` Necessário para visualizar o conteúdo codificado de um arquivo individual em um CodeCommit repositório a CodeCommit partir do console. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetFile](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetFile.html) | `codecommit:GetFile` Necessário para visualizar o conteúdo codificado de um arquivo individual e seus metadados em um CodeCommit repositório a partir do console. CodeCommit | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetFolder](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetFolder.html) | `codecommit:GetFolder` Necessário para visualizar o conteúdo de uma pasta especificada em um CodeCommit repositório a partir do CodeCommit console. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [PutFile](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_PutFile.html) | `codecommit:PutFile` Necessário para adicionar um arquivo novo ou modificado a um CodeCommit repositório a partir do CodeCommit console, CodeCommit da API ou do AWS CLI. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em comentários
As permissões a seguir permitem ou negam ações em comentários em CodeCommit repositórios. Essas permissões dizem respeito às ações realizadas com o CodeCommit console e a CodeCommit API e aos comandos executados usando o. AWS CLI Para permissões relacionadas em comentários em solicitações pull, consulte [Permissões para ações em solicitações pull](#aa-pr).
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para comentários em repositórios**
| CodeCommit Operações de API | Permissões obrigatórias (ações de API) | Recursos |
| --- | --- | --- |
| [DeleteCommentContent](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DeleteCommentContent.html) | `codecommit:DeleteCommentContent` Obrigatório para excluir o conteúdo de um comentário feito em uma alteração, um arquivo ou uma confirmação em um repositório. Comentários não podem ser excluídos, mas o conteúdo de um comentário pode ser removido se o usuário tem essa permissão. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetComment](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetComment.html) | `codecommit:GetComment` Obrigatório para retornar informações sobre um comentário feito em uma alteração, arquivo ou confirmação em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetCommentReactions](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetCommentReactions.html) | `codecommit:GetCommentReactions` Obrigatório para retornar informações sobre reações de emojis a um comentário feito em uma alteração, arquivo ou confirmação em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetCommentsForComparedCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetCommentsForComparedCommit.html) | `codecommit:GetCommentsForComparedCommit` Obrigatório para retornar informações sobre comentários feitos na comparação entre dois commits em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [PostCommentForComparedCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_PostCommentForComparedCommit.html) | `codecommit:PostCommentForComparedCommit` Necessário para criar um comentário sobre a comparação entre dois commits em um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [PostCommentReply](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_PostCommentReply.html) | `codecommit:PostCommentReply` Obrigatório para criar uma resposta a um comentário em uma comparação entre confirmações ou em uma solicitação pull. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [PutCommentReaction](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_PutCommentReaction.html) | `codecommit:PutCommentReaction` Obrigatório para criar ou atualizar uma reação de emoji em um comentário. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UpdateComment](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdateComment.html) | `codecommit:UpdateComment` Obrigatório para editar um comentário em uma comparação entre confirmações ou em uma solicitação pull. Comentários só podem ser editados pelo autor do comentário. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações no código confirmado
As seguintes permissões permitem ou negam ações no código confirmado com os repositórios do CodeCommit. Essas permissões dizem respeito às ações realizadas com o CodeCommit console e a CodeCommit API, e aos comandos executados usando o. AWS CLI Elas não pertencem a ações semelhantes que podem ser realizadas usando o protocolo Git. Por exemplo, o comando **git commit** cria uma confirmação para uma ramificação em um repositório usando o protocolo Git. Ele não é afetado por nenhuma permissão para a CodeCommit `CreateCommit` operação.
Negar explicitamente algumas dessas permissões pode resultar em consequências inesperadas no CodeCommit console. Por exemplo, configurar `GetTree` como `Deny` impede que os usuários naveguem pelo conteúdo de um repositório no console, mas não os impede de visualizar o conteúdo de um arquivo no repositório (se eles receberem um link para o arquivo no e-mail, por exemplo). Definir `GetBlob` como `Deny` impede os usuários de visualizar o conteúdo dos arquivos, mas não os impede de navegar pela estrutura de um repositório. Definir `GetCommit` como `Deny` impede que os usuários recuperem detalhes sobre confirmações. Definir `GetObjectIdentifier` como `Deny` bloqueia a maioria das funcionalidades da navegação de código. Se você definir todas essas três ações `Deny` em uma política, um usuário com essa política não poderá procurar código no CodeCommit console.
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em código comprometido**
| CodeCommit Operações de API | Permissões obrigatórias (ações de API) | Recursos |
| --- | --- | --- |
| BatchGetCommits | `codecommit:BatchGetCommits` Obrigatório para retornar informações sobre uma ou mais confirmações em um repositório do CodeCommit . Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [CreateCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/CreateCommit.html) | `codecommit:CreateCommit` Obrigatório para criar uma confirmação. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/GetCommit.html) | `codecommit:GetCommit` Obrigatório para retornar informações sobre uma confirmação. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| GetCommitHistory | `codecommit:GetCommitHistory` Obrigatório para retornar informações sobre o histórico de confirmações em um repositório. Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetDifferences](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetDifferences.html) | `codecommit:GetDifferences` Obrigatório para retornar informações sobre as diferenças entre os especificadores de confirmação (como uma ramificação, uma tag, um HEAD, um ID de confirmação ou outra referência totalmente qualificada). | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| GetObjectIdentifier | codecommit:GetObjectIdentifierObrigatório para resolver blobs, árvores e confirmações ao respectivo identificador. Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| GetReferences | codecommit:GetReferencesObrigatório para retornar todas as referências, como ramificações e tags. Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| GetTree | codecommit:GetTreeNecessário para visualizar o conteúdo de uma árvore especificada em um CodeCommit repositório a partir do CodeCommit console. Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em repositórios
As permissões a seguir permitem ou negam ações em CodeCommit repositórios. Essas permissões dizem respeito às ações realizadas com o CodeCommit console e a CodeCommit API e aos comandos executados usando o. AWS CLI Elas não pertencem a ações semelhantes que podem ser realizadas usando o protocolo Git.
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em repositórios**
| CodeCommit Operações de API | Permissões obrigatórias (ações de API) | Recursos |
| --- | --- | --- |
| [BatchGetRepositories](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_BatchGetRepositories.html) | `codecommit:BatchGetRepositories` Necessário para obter informações sobre vários CodeCommit repositórios em uma conta da Amazon Web Services. Em`Resource`, você deve especificar os nomes de todos os CodeCommit repositórios para os quais um usuário tem permissão (ou negação) de informações. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [CreateRepository](https://docs.aws.amazon.com/codecommit/latest/APIReference/CreateRepository.html) | `codecommit:CreateRepository` Necessário para criar um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [DeleteRepository](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_DeleteRepository.html) | `codecommit:DeleteRepository` Necessário para excluir um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetRepository](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetRepository.html) | `codecommit:GetRepository` Obrigatório para obter informações sobre um único repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [ListRepositories](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_ListRepositories.html) | codecommit:ListRepositoriesNecessário para obter uma lista dos nomes e IDs do sistema de vários CodeCommit repositórios para uma conta da Amazon Web Services. O único valor permitido de `Resource` para essa ação são todos os repositórios (`*`). | \$1 |
| [UpdateRepositoryDescription](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdateRepositoryDescription.html) | codecommit:UpdateRepositoryDescriptionNecessário para alterar a descrição de um CodeCommit repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UpdateRepositoryName](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UpdateRepositoryName.html) | codecommit:UpdateRepositoryNameNecessário para alterar o nome de um CodeCommit repositório. Em`Resource`, você deve especificar os CodeCommit repositórios que podem ser alterados e os novos nomes dos repositórios. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em tags
As permissões a seguir permitem ou negam ações em AWS tags para CodeCommit recursos.
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em tags**
| CodeCommit Operações de API | Permissões obrigatórias (ações de API) | Recursos |
| --- | --- | --- |
| [ListTagsForResource](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_ListTagsForResource.html) | `codecommit:ListTagsForResource` Obrigatório para retornar informações sobre AWS tags configuradas em um recurso em CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [TagResource](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_TagResource.html) | `codecommit:TagResource` Necessário para adicionar ou editar AWS tags para um recurso em CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [UntagResource](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_UntagResource.html) | `codecommit:UntagResource` Necessário para remover AWS tags de um recurso em CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações em acionadores
As seguintes permissões permitem ou negam ações em triggers para repositórios do CodeCommit.
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações em gatilhos**
| CodeCommit Operações de API | Permissões obrigatórias (ações de API) | Recursos |
| --- | --- | --- |
| [GetRepositoryTriggers](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetRepositoryTriggers.html) | `codecommit:GetRepositoryTriggers` Obrigatório para retornar informações sobre acionadores configurados para um repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [PutRepositoryTriggers](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_PutRepositoryTriggers.html) | `codecommit:PutRepositoryTriggers` Obrigatório para criar, editar ou excluir triggers para um repositório. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [TestRepositoryTriggers](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_TestRepositoryTriggers.html) | `codecommit:TestRepositoryTriggers` Obrigatório para testar a funcionalidade de um trigger de repositório enviando dados para o tópico ou a função configurada para o trigger. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
## Permissões para ações na CodePipeline integração
CodePipeline Para usar um CodeCommit repositório em uma ação de origem para um pipeline, você deve conceder todas as permissões listadas na tabela a seguir à função de serviço de. CodePipeline Caso essas permissões não sejam definidas na função de serviço ou estejam definidas como **Deny**, o pipeline não será executado automaticamente quando uma alteração for feita ao repositório, e as alterações não poderão ser liberadas manualmente.
Use as barras de rolagem para ver o restante da tabela.
**CodeCommit Operações de API e permissões necessárias para ações na CodePipeline integração**
| CodeCommit Operações de API | Permissões obrigatórias (ações de API) | Recursos |
| --- | --- | --- |
| [GetBranch](https://docs.aws.amazon.com/codecommit/latest/APIReference/API_GetBranch.html) | `codecommit:GetBranch` Obrigatório para obter detalhes sobre uma ramificação em um repositório do CodeCommit. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| [GetCommit](https://docs.aws.amazon.com/codecommit/latest/APIReference/GetCommit.html) | `codecommit:GetCommit` Obrigatório para retornar informações sobre um compromisso com a função de serviço do CodePipeline. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| UploadArchive | `codecommit:UploadArchive` Necessário para permitir que a função de serviço carregue as alterações do repositório em um pipeline. CodePipeline Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| GetUploadArchiveStatus | `codecommit:GetUploadArchiveStatus` Obrigatório para determinar o status de um upload de arquivamento: se ele está em andamento, concluído, cancelado ou se ocorreu um erro. Esta é apenas uma permissão de política do IAM e não uma ação de API que você pode chamar. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
| CancelUploadArchive | codecommit:CancelUploadArchiveObrigatório para cancelar o upload de um arquivamento para um pipeline. Esta é apenas uma permissão da política do IAM e não uma ação de API que possa ser chamada. | arn: aws:codecommit::: *region* *account-id* *repository-name* |
# Como AWS CodeCommit funciona com o IAM
Antes de usar o IAM para gerenciar o acesso CodeCommit, você deve entender quais recursos do IAM estão disponíveis para uso CodeCommit. Para ter uma visão de alto nível de como CodeCommit e outros AWS serviços funcionam com o IAM, consulte [AWS Serviços que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
**Topics**
+ [Chaves de condição](#security_iam_service-with-iam-id-based-policies-conditionkeys)
+ [Exemplos](#security_iam_service-with-iam-id-based-policies-examples)
## Chaves de condição
Os administradores podem usar políticas AWS JSON para especificar quem tem acesso ao quê. Ou seja, qual **entidade principal** pode executar **ações** em quais **recursos** e em que **condições**.
O elemento `Condition` especifica quando as instruções são executadas com base em critérios definidos. É possível criar expressões condicionais que usem [agentes de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html), como “igual a” ou “menor que”, para fazer a condição da política corresponder aos valores na solicitação. Para ver todas as chaves de condição AWS globais, consulte as [chaves de contexto de condição AWS global](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
CodeCommit define seu próprio conjunto de chaves de condição e também oferece suporte ao uso de algumas chaves de condição globais. Para ver todas as chaves de condição AWS globais, consulte [Chaves de contexto de condição AWS global](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) no *Guia do usuário do IAM*.
Algumas CodeCommit ações suportam a chave de `codecommit:References` condição. Para obter um exemplo de política que usa essa chave, consulte [Exemplo 4: negar ou permitir ações em ramificações](customer-managed-policies.md#identity-based-policies-example-4).
Para ver uma lista de chaves de CodeCommit condição, consulte [Chaves de condição AWS CodeCommit](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awscodecommit.html#awscodecommit-policy-keys) no *Guia do usuário do IAM*. Para saber com quais ações e recursos você pode usar uma chave de condição, consulte [Ações definidas por AWS CodeCommit](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awscodecommit.html#awscodecommit-actions-as-permissions).
## Exemplos
Para ver exemplos de políticas CodeCommit baseadas em identidade, consulte. [AWS CodeCommit exemplos de políticas baseadas em identidade](security-iam.md#security_iam_id-based-policy-examples)
## CodeCommit políticas baseadas em recursos
CodeCommit não oferece suporte a políticas baseadas em recursos.
## Autorização baseada em CodeCommit tags
Você pode anexar tags a CodeCommit recursos ou passar tags em uma solicitação para CodeCommit. Para controlar o acesso baseado em tags, forneça informações sobre as tags no [elemento de condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) de uma política usando as `codecommit:ResourceTag/key-name`, `aws:RequestTag/key-name` ou chaves de condição `aws:TagKeys`. Para obter mais informações sobre a marcação de CodeCommit recursos, consulte[Exemplo 5: negar ou permitir ações em repositórios com tags](customer-managed-policies.md#identity-based-policies-example-5). Para obter mais informações sobre estratégias de marcação, consulte Recursos de [marcação AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).
CodeCommit também oferece suporte a políticas baseadas em tags de sessão. Para obter mais informações, consulte [Tags de sessão](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html).
### Usando tags para fornecer informações de identidade em CodeCommit
CodeCommit suporta o uso de tags de sessão, que são atributos de pares de valores-chave que você transmite quando assume uma função do IAM, usa credenciais temporárias ou federa um usuário em (). AWS Security Token Service AWS STS Você também pode associar tags a um usuário do IAM. Você pode usar as informações fornecidas nessas tags para facilitar a identificação de quem fez uma alteração ou causou um evento. CodeCommit inclui os valores das tags com os seguintes nomes de chave em CodeCommit eventos:
****
| Nome da chave | Valor |
| --- | --- |
| displayName | O nome legível por humanos para exibir e associar ao usuário (por exemplo, Mary Major ou Saanvi Sarkar). |
| emailAddress | O endereço de e-mail que você deseja exibir e associar ao usuário (por exemplo, mary\$1major@examplo.com ou saanvi\$1sarkar@examplo.com). |
Se essas informações forem fornecidas, CodeCommit inclua-as nos eventos enviados à Amazon EventBridge e à Amazon CloudWatch Events. Para obter mais informações, consulte [Monitorar eventos do CodeCommit no Amazon EventBridge e no Amazon CloudWatch Events](monitoring-events.md).
Para usar a marcação de sessão, as funções devem ter políticas que incluam a permissão `sts:TagSession` definida como `Allow`. Se você estiver usando o acesso federado, poderá configurar as informações de nome de exibição e tag de e-mail como parte da sua configuração. Por exemplo, se você estiver usando o Azure Active Directory, poderá fornecer as seguintes informações de reivindicação:
****
| Nome da reivindicação | Valor |
| --- | --- |
| https://aws.amazon.com/SAML/Attributes/PrincipalTag:displayName | user.displayname |
| https://aws.amazon.com/SAML/Attributes/PrincipalTag:emailAddress | user.mail |
Você pode usar o AWS CLI para passar tags de sessão para `displayName` e `emailAddress` usar**AssumeRole**. Por exemplo, um usuário que deseja assumir uma função chamada *Developer* que deseja associar seu nome *Mary Major* pode usar o **assume-role** comando semelhante ao seguinte:
```
aws sts assume-role \
--role-arn arn:aws:iam::123456789012:role/Developer \
--role-session-name Mary-Major \
–-tags Key=displayName,Value="Mary Major" Key=emailAddress,Value="mary_major@example.com" \
--external-id Example987
```
Para obter mais informações, consulte [AssumeRole](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_adding-assume-role).
Você pode usar a operação `AssumeRoleWithSAML` para retornar um conjunto de credenciais temporárias que incluem as tags `displayName` e `emailAddress`. Você pode usar essas tags ao acessar repositórios de CodeCommit. Isso exige que sua empresa ou grupo já tenha integrado sua solução SAML de terceiros com AWS. Em caso afirmativo, é possível transmitir atributos SAML como tags de sessão. Por exemplo, se você quiser passar atributos de identidade para um nome de exibição e endereço de e-mail para um usuário chamado *Saanvi Sarkar* como tags de sessão:
```
Saanvi Sarkar
saanvi_sarkar@example.com
```
Para obter mais informações, consulte Como [passar tags de sessão usando AssumeRoleWith SAML.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_adding-assume-role-saml)
Você pode usar a operação `AssumeRoleWithIdentity` para retornar um conjunto de credenciais temporárias que incluem as tags `displayName` e `emailAddress`. Você pode usar essas tags ao acessar repositórios de CodeCommit. Para passar tags de sessão do OpenID Connect (OIDC), é necessário incluir as tags de sessão no JSON Web Token (JWT). Por exemplo, o token JWP decodificado usado para chamar inclui `AssumeRoleWithWebIdentity` as tags `displayName` e de `emailAddress` sessão de um usuário chamado: *Li Juan*
```
{
"sub": "lijuan",
"aud": "ac_oic_client",
"jti": "ZYUCeREXAMPLE",
"iss": "https://xyz.com",
"iat": 1566583294,
"exp": 1566583354,
"auth_time": 1566583292,
"https://aws.amazon.com/tags": {
"principal_tags": {
"displayName": ["Li Juan"],
"emailAddress": ["li_juan@example.com"],
},
"transitive_tag_keys": [
"displayName",
"emailAddress"
]
}
}
```
Para obter mais informações, consulte [Passando tags de sessão usando AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_adding-assume-role-idp).
Você pode usar a operação `GetFederationToken` para retornar um conjunto de credenciais temporárias que incluem as tags `displayName` e `emailAddress`. Você pode usar essas tags ao acessar repositórios de CodeCommit. Por exemplo, para usar o AWS CLI para obter um token de federação que inclua as `emailAddress` tags `displayName` e:
```
aws sts get-federation-token \
--name my-federated-user \
–-tags key=displayName,value="Nikhil Jayashankar" key=emailAddress,value=nikhil_jayashankar@example.com
```
Para obter mais informações, consulte [Passando tags de sessão usando GetFederationToken](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html#id_session-tags_adding-getfederationtoken).
## CodeCommit Funções do IAM
Um [perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) é uma entidade dentro da sua conta da Amazon Web Services que tem permissões específicas.
### Usando credenciais temporárias com CodeCommit
É possível usar credenciais temporárias para fazer login com federação, assumir um perfil do IAM ou assumir um perfil entre contas. Você obtém credenciais de segurança temporárias chamando operações de AWS STS API, como [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)ou [GetFederationToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html).
CodeCommit suporta o uso de credenciais temporárias. Para obter mais informações, consulte [Conectando-se a AWS CodeCommit repositórios com credenciais rotativas](temporary-access.md).
### Perfis vinculados ao serviço
[As funções vinculadas ao serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) permitem que AWS os serviços acessem recursos em outros serviços para concluir uma ação em seu nome. Os perfis vinculados a serviço aparecem em sua conta do IAM e são de propriedade do serviço. Um administrador do IAM pode visualizar, mas não pode editar as permissões para perfis vinculados a serviço.
CodeCommit não usa funções vinculadas ao serviço.
### Perfis de serviço
Esse atributo permite que um serviço assuma um [perfil de serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-role) em seu nome. O perfil permite que o serviço acesse recursos em outros serviços para concluir uma ação em seu nome. Os perfis de serviço aparecem em sua conta do IAM e são de propriedade da conta. Isso significa que um administrador do IAM pode alterar as permissões para esse perfil. Porém, fazer isso pode alterar a funcionalidade do serviço.
CodeCommit não usa funções de serviço.
## AWS CodeCommit exemplos de políticas baseadas em identidade
Por padrão, os usuários e os perfis do IAM não têm permissão para criar ou modificar recursos do CodeCommit . Eles também não podem realizar tarefas usando a AWS API Console de gerenciamento da AWS AWS CLI, ou. Um administrador do IAM deve criar políticas do IAM que concedam aos usuários e perfis permissão para executarem operações de API específicas nos recursos especificados de que precisam. O administrador deve anexar essas políticas aos usuários ou grupos do IAM que exigem essas permissões.
Para obter exemplos de políticas, consulte:
+ [Exemplo 1: Permitir que um usuário realize CodeCommit operações em uma única Região da AWS](customer-managed-policies.md#identity-based-policies-example-1)
+ [Exemplo 2: permitir que um usuário use o Git para um único repositório](customer-managed-policies.md#identity-based-policies-example-2)
+ [Exemplo 3: permitir que um usuário conectado a partir de um intervalo de endereços IP especificado acesse um repositório](customer-managed-policies.md#identity-based-policies-example-3)
+ [Exemplo 4: negar ou permitir ações em ramificações](customer-managed-policies.md#identity-based-policies-example-4)
+ [Exemplo 5: negar ou permitir ações em repositórios com tags](customer-managed-policies.md#identity-based-policies-example-5)
+ [Configurar o acesso entre contas a um AWS CodeCommit repositório usando funções](cross-account.md)
Para saber como criar uma política baseada em identidade do IAM usando esses exemplos de documentos de política JSON, consulte [Criar políticas na guia JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) no *Guia do usuário do IAM*.
**Topics**
+ [Práticas recomendadas de política](#security_iam_service-with-iam-policy-best-practices)
+ [Usando o CodeCommit console](#security_iam_id-based-policy-examples-console)
+ [Permitir que os usuários visualizem suas próprias permissões](#security_iam_id-based-policy-examples-view-own-permissions)
+ [Visualização CodeCommit *repositories* com base em tags](#security_iam_id-based-policy-examples-view-repositories-tags)
### Práticas recomendadas de política
As políticas baseadas em identidade determinam se alguém pode criar, acessar ou excluir CodeCommit recursos em sua conta. Essas ações podem incorrer em custos para sua Conta da AWS. Ao criar ou editar políticas baseadas em identidade, siga estas diretrizes e recomendações:
+ **Comece com as políticas AWS gerenciadas e avance para as permissões de privilégios mínimos — Para começar a conceder permissões** aos seus usuários e cargas de trabalho, use as *políticas AWS gerenciadas* que concedem permissões para muitos casos de uso comuns. Eles estão disponíveis no seu Conta da AWS. Recomendamos que você reduza ainda mais as permissões definindo políticas gerenciadas pelo AWS cliente que sejam específicas para seus casos de uso. Para saber mais, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) ou [Políticas gerenciadas pela AWS para funções de trabalho](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html) no *Guia do usuário do IAM*.
+ **Aplique permissões de privilégio mínimo**: ao definir permissões com as políticas do IAM, conceda apenas as permissões necessárias para executar uma tarefa. Você faz isso definindo as ações que podem ser executadas em recursos específicos sob condições específicas, também conhecidas como *permissões de privilégio mínimo*. Para saber mais sobre como usar o IAM para aplicar permissões, consulte [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
+ **Use condições nas políticas do IAM para restringir ainda mais o acesso**: é possível adicionar uma condição às políticas para limitar o acesso a ações e recursos. Por exemplo, é possível escrever uma condição de política para especificar que todas as solicitações devem ser enviadas usando SSL. Você também pode usar condições para conceder acesso às ações de serviço se elas forem usadas por meio de uma ação específica AWS service (Serviço da AWS), como CloudFormation. Para saber mais, consulte [Elementos da política JSON do IAM: condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) no *Guia do usuário do IAM*.
+ **Use o IAM Access Analyzer para validar suas políticas do IAM a fim de garantir permissões seguras e funcionais**: o IAM Access Analyzer valida as políticas novas e existentes para que elas sigam a linguagem de política do IAM (JSON) e as práticas recomendadas do IAM. O IAM Access Analyzer oferece mais de cem verificações de política e recomendações práticas para ajudar a criar políticas seguras e funcionais. Para saber mais, consulte [Validação de políticas do IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-policy-validation.html) no *Guia do Usuário do IAM*.
+ **Exigir autenticação multifator (MFA**) — Se você tiver um cenário que exija usuários do IAM ou um usuário root, ative Conta da AWS a MFA para obter segurança adicional. Para exigir MFA quando as operações de API forem chamadas, adicione condições de MFA às suas políticas. Para saber mais, consulte [Configuração de acesso à API protegido por MFA](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa_configure-api-require.html) no *Guia do Usuário do IAM*.
Para saber mais sobre as práticas recomendadas do IAM, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
### Usando o CodeCommit console
Para acessar o AWS CodeCommit console, você deve ter um conjunto mínimo de permissões. Essas permissões devem permitir que você liste e visualize detalhes sobre os CodeCommit recursos em sua conta da Amazon Web Services. Se você criar uma política baseada em identidade que seja mais restritiva que as permissões mínimas necessárias, o console não funcionará como pretendido para entidades (usuários ou perfis do IAM) com essa política.
Para garantir que essas entidades ainda possam usar o CodeCommit console, anexe também a seguinte política AWS gerenciada às entidades. Para obter mais informações, consulte [Adição de permissões a um usuário](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Manual do usuário do IAM*:
Para obter mais informações, consulte [Usando políticas baseadas em identidade (políticas do IAM) para CodeCommit](auth-and-access-control-iam-identity-based-access-control.md).
Você não precisa permitir permissões mínimas do console para usuários que estão fazendo chamadas somente para a API AWS CLI ou para a AWS API. Em vez disso, permita o acesso somente às ações que correspondem à operação da API que você está tentando executar.
### Permitir que os usuários visualizem suas próprias permissões
Este exemplo mostra como criar uma política que permita que os usuários do IAM visualizem as políticas gerenciadas e em linha anexadas a sua identidade de usuário. Essa política inclui permissões para concluir essa ação no console ou programaticamente usando a API AWS CLI ou AWS .
```
{
"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": "*"
}
]
}
```
### Visualização CodeCommit *repositories* com base em tags
É possível utilizar condições na política baseada em identidade para controlar o acesso aos recursos do CodeCommit com base em tags. Para obter um exemplo de política que demonstra como fazer isso, consulte [Exemplo 5: negar ou permitir ações em repositórios com tags](customer-managed-policies.md#identity-based-policies-example-5).
Para obter mais informações, consulte [IAM JSON Policy Elements: Condition](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) (Elementos da política JSON do IAM: Condição) no *Guia do usuário do IAM*.
## Solução de problemas AWS CodeCommit de identidade e acesso
Use as informações a seguir para ajudá-lo a diagnosticar e corrigir problemas comuns que você pode encontrar ao trabalhar com CodeCommit um IAM.
**Topics**
+ [Não estou autorizado a realizar uma ação em CodeCommit](#security_iam_troubleshoot-no-permissions)
+ [Não estou autorizado a realizar iam: PassRole](#security_iam_troubleshoot-passrole)
+ [Quero visualizar minhas chaves de acesso](#security_iam_troubleshoot-access-keys)
+ [Sou administrador e quero permitir que outras pessoas acessem CodeCommit](#security_iam_troubleshoot-admin-delegate)
+ [Quero permitir que pessoas fora da minha conta da Amazon Web Services acessem meus CodeCommit recursos](#security_iam_troubleshoot-cross-account-access)
### Não estou autorizado a realizar uma ação em CodeCommit
Se isso Console de gerenciamento da AWS indicar que você não está autorizado a realizar uma ação, entre em contato com o administrador para obter ajuda. Caso seu administrador seja a pessoa que forneceu suas credenciais de início de sessão.
Para obter mais informações, consulte [Permissões necessárias para usar o CodeCommit console](auth-and-access-control-iam-identity-based-access-control.md#console-permissions).
### Não estou autorizado a realizar iam: PassRole
Se você receber uma mensagem de erro informando que não está autorizado a executar a ação `iam:PassRole`, as suas políticas devem ser atualizadas para permitir que você passe uma função para o CodeCommit.
Alguns Serviços da AWS permitem que você passe uma função existente para esse serviço em vez de criar uma nova função de serviço ou uma função vinculada ao serviço. Para fazê-lo, você deve ter permissões para passar o perfil para o serviço.
O exemplo de erro a seguir ocorre quando uma usuária do IAM chamada `marymajor` tenta utilizar o console para executar uma ação no CodeCommit. No entanto, a ação exige que o serviço tenha permissões concedidas por um perfil de serviço. Mary não tem permissões para passar o perfil para o serviço.
```
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
```
Nesse caso, as políticas de Mary devem ser atualizadas para permitir que ela realize a ação `iam:PassRole`.
Se precisar de ajuda, entre em contato com seu AWS administrador. Seu administrador é a pessoa que forneceu suas credenciais de login.
### Quero visualizar minhas chaves de acesso
Depois de criar suas chaves de acesso de usuário do IAM, é possível visualizar seu ID da chave de acesso a qualquer momento. No entanto, você não pode visualizar sua chave de acesso secreta novamente. Se você perder sua chave secreta, crie um novo par de chaves de acesso.
As chaves de acesso consistem em duas partes: um ID de chave de acesso (por exemplo, `AKIAIOSFODNN7EXAMPLE`) e uma chave de acesso secreta (por exemplo, `wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY`). Como um nome de usuário e uma senha, você deve usar o ID da chave de acesso e a chave de acesso secreta em conjunto para autenticar suas solicitações. Gerencie suas chaves de acesso de forma tão segura quanto você gerencia seu nome de usuário e sua senha.
**Importante**
Não forneça as chaves de acesso a terceiros, mesmo que seja para ajudar a [encontrar o ID de usuário canônico](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html#FindCanonicalId). Ao fazer isso, você pode dar a alguém acesso permanente ao seu Conta da AWS.
Ao criar um par de chaves de acesso, você é solicitado a guardar o ID da chave de acesso e a chave de acesso secreta em um local seguro. A chave de acesso secreta só está disponível no momento em que é criada. Se você perder sua chave de acesso secreta, será necessário adicionar novas chaves de acesso para seu usuário do IAM. Você pode ter no máximo duas chaves de acesso. Se você já tiver duas, você deverá excluir um par de chaves para poder criar um novo. Para visualizar as instruções, consulte [Gerenciar chaves de acesso](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey) no *Guia do usuário do IAM*.
### Sou administrador e quero permitir que outras pessoas acessem CodeCommit
Para permitir que outras pessoas acessem CodeCommit, você deve conceder permissão às pessoas ou aplicativos que precisam de acesso. Se você estiver usando o Centro de Identidade do AWS IAM para gerenciar pessoas e aplicações, atribua conjuntos de permissões a usuários ou grupos para definir o nível de acesso. Os conjuntos de permissões criam e atribuem automaticamente políticas do IAM aos perfis do IAM associados à pessoa ou aplicação. Para ter mais informações, consulte [Conjuntos de permissões](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
Se você não estiver usando o Centro de Identidade do IAM, deverá criar entidades do IAM (usuários ou perfis) para as pessoas ou aplicações que precisam de acesso. Você deve anexar uma política à entidade que concede a eles as permissões corretas no CodeCommit. Depois que as permissões forem concedidas, forneça as credenciais ao usuário ou desenvolvedor da aplicação. Eles usarão essas credenciais para acessar AWS. Para saber mais sobre como criar grupos, políticas, permissões e usuários do IAM, consulte [Identidades do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) e [Políticas e permissões no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.
### Quero permitir que pessoas fora da minha conta da Amazon Web Services acessem meus CodeCommit recursos
Para obter mais informações, consulte [Configurar o acesso entre contas a um AWS CodeCommit repositório usando funções](cross-account.md).
# Resiliência no AWS CodeCommit
A infraestrutura global da AWS se baseia em Regiões da AWS e zonas de disponibilidade. A Regiões da AWS oferece várias zonas de disponibilidade separadas e isoladas fisicamente que são conectadas com baixa latência, throughputs elevadas e em redes altamente redundantes. Com as zonas de disponibilidade, é possível projetar e operar aplicações e bancos de dados que automaticamente executam o failover entre as zonas sem interrupção. As zonas de disponibilidade são altamente disponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais.
Existe um repositório do CodeCommit ou modelo de regra de aprovação do CodeCommit na Região da AWS em que foi criado. Para obter mais informações, consulte [Regiões e endpoints de conexão Git para AWS CodeCommit](regions.md). Para resiliência em repositórios, você pode configurar seu cliente Git para enviar via push para dois repositórios ao mesmo tempo. Para obter mais informações, consulte [Confirmações de push em um repositório do Git adicional](how-to-mirror-repo-pushes.md).
Para obter mais informações sobre Regiões da AWS e zonas de disponibilidade, consulte [Infraestrutura global da AWS](https://aws.amazon.com/about-aws/global-infrastructure/).
# Segurança da infraestrutura no AWS CodeCommit
Como um serviço gerenciado, o AWS CodeCommit é protegido pelos procedimentos de segurança de rede global da AWS que estão descritos no whitepaper [Amazon Web Services: Overview of Security Processes](https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf).
Você usa chamadas de API publicadas pela AWS para acessar o CodeCommit por meio da rede. Os clientes devem oferecer suporte a Transport Layer Security (TLS) 1.0 ou posterior. Recomendamos TLS 1.2 ou posterior. Os clientes também devem ter compatibilidade com conjuntos de criptografia com perfect forward secrecy (PFS) como Ephemeral Diffie-Hellman (DHE) ou Ephemeral Elliptic Curve Diffie-Hellman (ECDHE). A maioria dos sistemas modernos como Java 7 e versões posteriores oferece compatibilidade com esses modos.
As solicitações devem ser assinadas usando um ID da chave de acesso e uma chave de acesso secreta associada a uma entidade principal do IAM. Ou você pode usar o [AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html) (AWS STS) para gerar credenciais de segurança temporárias para assinar solicitações.
É possível chamar essas operações de API de qualquer local de rede, mas o CodeCommit oferece suporte a restrições com base no endereço IP de origem. Também é possível usar políticas do CodeCommit para controlar o acesso de endpoints específicos do Amazon Virtual Private Cloud (Amazon VPC) ou de VPCs específicas. Efetivamente, isso isola o acesso à rede para um determinado recurso do CodeCommit somente da VPC específica na rede da AWS.
Para obter mais informações, consulte:
+ [Exemplo 1: Permitir que um usuário realize CodeCommit operações em uma única Região da AWS](customer-managed-policies.md#identity-based-policies-example-1)
+ [Exemplo 3: permitir que um usuário conectado a partir de um intervalo de endereços IP especificado acesse um repositório](customer-managed-policies.md#identity-based-policies-example-3)
+ [Usando AWS CodeCommit com interface VPC endpoints](codecommit-and-interface-VPC.md)