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 de recursos do console do Developer Tools
A segurança na nuvem AWS é a maior prioridade. Como AWS cliente, você se beneficia de uma arquitetura de data center e rede criada para atender aos requisitos das organizações mais sensíveis à segurança.
A segurança é uma responsabilidade compartilhada entre você AWS e você. O [modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) descreve isto como segurança *da* nuvem e segurança *na* nuvem.
+ **Segurança da nuvem** — AWS é responsável por proteger a infraestrutura que executa AWS os serviços na AWS nuvem. AWS também fornece serviços que você pode usar com segurança. Auditores de terceiros 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 às AWS CodeStar notificações e AWS CodeConnections, consulte [AWS Serviços no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/).
+ **Segurança na nuvem** — Sua responsabilidade é determinada pelo AWS serviço 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 você a entender como aplicar o modelo de responsabilidade compartilhada ao usar AWS CodeStar Notificações AWS CodeConnections e. Os tópicos a seguir mostram como configurar AWS CodeStar as notificações e AWS CodeConnections cumprir seus objetivos de segurança e conformidade. Você também aprenderá a usar outros AWS serviços que ajudam a monitorar e proteger suas AWS CodeStar notificações e AWS CodeConnections recursos.
Para obter mais informações sobre segurança dos serviços no console do Developer Tools, consulte:
+ [CodeBuild Segurança](https://docs.aws.amazon.com/codebuild/latest/userguide/security.html)
+ [CodeCommit Segurança](https://docs.aws.amazon.com/codecommit/latest/userguide/security.html)
+ [CodeDeploy Segurança](https://docs.aws.amazon.com/codedeploy/latest/userguide/security.html)
+ [CodePipeline Segurança](https://docs.aws.amazon.com/codepipeline/latest/userguide/security.html)
## Noções básicas do conteúdo e da segurança das notificações
As notificações fornecem informações sobre recursos para os usuários inscritos nos destinos da regra de notificação que você configurar. Essas informações podem incluir detalhes sobre recursos do Developer Tools, incluindo conteúdo do repositório, status da compilação, status de implantação e execuções de pipeline.
Por exemplo, você pode configurar uma regra de notificação para um repositório CodeCommit para incluir comentários em commits ou pull requests. Se esse for o caso, as notificações enviadas em resposta a essa regra podem conter a linha ou as linhas de código às quais o comentário faz referência. Da mesma forma, você pode configurar uma regra de notificação para um projeto de compilação CodeBuild para incluir sucessos ou falhas em estados e fases de compilação. As notificações enviadas em resposta a essa regra conterão essas informações.
Você pode configurar uma regra de notificação para um funil de CodePipeline entrada para incluir informações sobre aprovações manuais, e as notificações enviadas em resposta a essa regra podem conter o nome da pessoa que fornece a aprovação. Você pode configurar uma regra de notificação para um aplicativo CodeDeploy para indicar o sucesso da implantação, e as notificações enviadas em resposta a essa regra podem conter informações sobre o destino da implantação.
As notificações podem incluir informações específicas ao projeto, como status de compilações, linhas de código que contêm comentários e aprovações de pipeline. Para ajudar a garantir a segurança do seu projeto, certifique-se de revisar regularmente os destinos das regras de notificação e a lista de assinantes dos tópicos do Amazon SNS especificados como destinos. Além disso, o conteúdo das notificações enviadas em resposta a eventos pode mudar à medida que recursos adicionais são adicionados aos serviços subjacentes. Essa alteração pode ocorrer sem aviso prévio para as regras de notificação já existentes. Considere revisar o conteúdo das mensagens de notificação periodicamente para ajudar a mantê-lo informado sobre o que está sendo enviado, bem como para quem está sendo enviado.
Para obter mais informações sobre os tipos de evento disponíveis para regras de notificação, consulte [Conceitos de notificação](concepts.md).
Você pode optar por limitar os detalhes incluídos nas notificações apenas ao que está incluído em um evento. Isso é o que é chamado de tipo de detalhe **Basic** (Básico). Esses eventos contêm exatamente as mesmas informações enviadas à Amazon EventBridge e à Amazon CloudWatch Events.
Os serviços de console do Developer Tools CodeCommit, como, podem optar por adicionar informações sobre alguns ou todos os seus tipos de eventos nas mensagens de notificação além do que está disponível em um evento. Essas informações adicionais podem ser adicionadas a qualquer momento para aprimorar os tipos de eventos atuais ou complementar os tipos de eventos futuros. Você pode optar por incluir qualquer informação complementar sobre o evento, se disponível, na notificação, escolhendo o tipo de detalhe **Full (Completo)**. Para obter mais informações, consulte [Tipos de detalhes](concepts.md#detail-type).
# Proteção de dados em AWS CodeStar notificações e AWS CodeConnections
O modelo de [responsabilidade AWS compartilhada modelo](https://aws.amazon.com/compliance/shared-responsibility-model/) de se aplica à proteção de dados em AWS CodeStar Notificações AWS CodeConnections e. Conforme descrito neste modelo, AWS é responsável por proteger a infraestrutura global que executa todos os Nuvem AWS. Você é responsável por manter o controle sobre o conteúdo hospedado nessa infraestrutura. Você também é responsável pelas tarefas de configuração e gerenciamento de segurança dos Serviços da AWS que usa. Para obter mais informações sobre a privacidade de dados, consulte as [Data Privacy FAQ](https://aws.amazon.com/compliance/data-privacy-faq/). Para obter mais informações sobre a proteção de dados na Europa, consulte a postagem do blog [AWS Shared Responsibility Model and RGPD](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) no *Blog de segurança da AWS *.
Para fins de proteção de dados, recomendamos que você proteja Conta da AWS as credenciais e configure usuários individuais com Centro de Identidade do AWS IAM ou AWS Identity and Access Management (IAM). Dessa maneira, cada usuário receberá apenas as permissões necessárias para cumprir suas obrigações de trabalho. Recomendamos também que você proteja seus dados das seguintes formas:
+ Use uma autenticação multifator (MFA) com cada conta.
+ Use SSL/TLS para se comunicar com os recursos. AWS Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Configure a API e o registro de atividades do usuário com AWS CloudTrail. Para obter informações sobre o uso de CloudTrail trilhas para capturar AWS atividades, consulte Como [trabalhar com CloudTrail trilhas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) no *Guia AWS CloudTrail do usuário*.
+ Use soluções de AWS criptografia, juntamente com todos os controles de segurança padrão Serviços da AWS.
+ Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e proteger dados sigilosos armazenados no Amazon S3.
+ Se você precisar de módulos criptográficos validados pelo FIPS 140-3 ao acessar AWS por meio de uma interface de linha de comando ou de uma API, use um endpoint FIPS. Para obter mais informações sobre os endpoints FIPS disponíveis, consulte [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
É altamente recomendável que nunca sejam colocadas informações confidenciais ou sigilosas, como endereços de e-mail de clientes, em tags ou campos de formato livre, como um campo **Nome**. Isso inclui quando você trabalha com AWS CodeStar Notificações AWS CodeConnections e/ou outros Serviços da AWS usando o console AWS CLI, a API ou AWS SDKs. Quaisquer dados inseridos em tags ou em campos de texto de formato livre usados para nomes podem ser usados para logs de faturamento ou de diagnóstico. Se você fornecer um URL para um servidor externo, é fortemente recomendável que não sejam incluídas informações de credenciais no URL para validar a solicitação nesse servidor.
# Gerenciamento de identidade e acesso para AWS CodeStar notificações e AWS CodeConnections
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 AWS CodeStar notificações e AWS CodeConnections recursos. O IAM é um AWS service (Serviço da AWS) que você pode usar sem custo adicional.
**nota**
Ações para recursos criados sob o novo prefixo de serviço `codeconnections` estão disponíveis. A criação de um recurso com o novo prefixo de serviço será usada `codeconnections` no ARN do recurso. As ações e os recursos para o prefixo `codestar-connections` de serviço permanecem disponíveis. Ao especificar um recurso na política do IAM, o prefixo do serviço precisa corresponder ao do recurso.
**Topics**
+ [Público](#security_iam_audience)
+ [Autenticação com identidades](#security_iam_authentication)
+ [Gerenciar o acesso usando políticas](#security_iam_access-manage)
+ [Como os recursos no console do Developer Tools funcionam com o IAM](security_iam_service-with-iam.md)
+ [AWS CodeConnections referência de permissões](#permissions-reference-connections)
+ [Exemplos de políticas baseadas em identidade](security_iam_id-based-policy-examples.md)
+ [Usando tags para controlar o acesso aos AWS CodeConnections recursos](connections-tag-based-access-control.md)
+ [Uso de notificações e conexões no 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)
+ [AWS CodeStar Notificações de solução de problemas, AWS CodeConnections identidade e acesso](security_iam_troubleshoot.md)
+ [Usando funções vinculadas a serviços para notificações AWS CodeStar](using-service-linked-roles.md)
+ [Usando funções vinculadas a serviços para Conexões de código da AWS](service-linked-role-connections.md)
+ [AWS políticas gerenciadas para Conexões de código da AWS](security-iam-awsmanpol.md)
## 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 [AWS CodeStar Notificações de solução de problemas, AWS CodeConnections identidade e acesso](security_iam_troubleshoot.md)).
+ **Administrador do serviço**: determine o acesso do usuário e envie solicitações de permissão (consulte [Como os recursos no console do Developer Tools funcionam com o IAM](security_iam_service-with-iam.md))
+ **Administrador do IAM**: escreva políticas para gerenciar o acesso (consulte [Exemplos de políticas baseadas em identidade](security_iam_id-based-policy-examples.md))
## 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*.
### Usuário raiz da conta da AWS
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*.
# Como os recursos no console do Developer Tools funcionam com o IAM
Antes de usar o IAM para gerenciar o acesso a recursos no console do Developer Tools, você deve entender quais recursos do IAM estão disponíveis para uso com ele. Para ter uma visão de alto nível de como as notificações e outros AWS serviços funcionam com o IAM, consulte [AWS os 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**
+ [Políticas baseadas em identidade no console do Developer Tools.](#security_iam_service-with-iam-id-based-policies)
+ [AWS CodeStar Notificações e políticas AWS CodeConnections baseadas em recursos](#security_iam_service-with-iam-resource-based-policies)
+ [Autorização baseada em tags do](#security_iam_service-with-iam-tags)
+ [Perfis do IAM](#security_iam_service-with-iam-roles)
## Políticas baseadas em identidade no console do Developer Tools.
Com as políticas baseadas em identidade do IAM, é possível especificar ações e recursos permitidos ou negados, assim como as condições sob as quais as ações são permitidas ou negadas. AWS CodeStar Notificações e AWS CodeConnections suporte a ações, recursos e chaves de condição específicos. Para saber mais sobre todos os elementos usados em uma política JSON, consulte [Referência de elementos de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) no *Guia do usuário do IAM*.
### Ações
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 `Action` de uma política JSON descreve as ações que podem ser usadas para permitir ou negar acesso em uma política. Incluem ações em uma política para conceder permissões para executar a operação associada.
As ações de política para notificações no console do Developer Tools usam o seguinte prefixo antes da ação: `codestar-notifications and codeconnections`. Por exemplo, para conceder permissão a alguém para visualizar todas as regras de notificação em sua conta, inclua a `codestar-notifications:ListNotificationRules` ação na política relacionada. As declarações de política devem incluir um `NotAction` elemento `Action` ou. AWS CodeStar Notificações e AWS CodeConnections define seu próprio conjunto de ações que descrevem as tarefas que você pode executar com esse serviço.
Para especificar várias ações de AWS CodeStar Notificações em uma única instrução, separe-as com vírgulas da seguinte maneira.
```
"Action": [
"codestar-notifications:action1",
"codestar-notifications:action2"
```
Para especificar várias Conexões de código da AWS ações em uma única declaração, separe-as com vírgulas da seguinte maneira.
```
"Action": [
"codeconnections:action1",
"codeconnections:action2"
```
Você também pode especificar várias ações utilizando caracteres curinga (\$1). Por exemplo, para especificar todas as ações que começam com a palavra `List`, inclua a ação a seguir:
```
"Action": "codestar-notifications:List*"
```
AWS CodeStar As ações da API de notificações incluem:
+ `CreateNotificationRule`
+ `DeleteNotificationRule`
+ `DeleteTarget`
+ `DescribeNotificationRule`
+ `ListEventTypes`
+ `ListNotificationRules`
+ `ListTagsForResource`
+ `ListTargets`
+ `Subscribe`
+ `TagResource`
+ `Unsubscribe`
+ `UntagResource`
+ `UpdateNotificationRule`
Conexões de código da AWS As ações da API incluem o seguinte:
+ `CreateConnection`
+ `DeleteConnection`
+ `GetConnection`
+ `ListConnections`
+ `ListTagsForResource`
+ `TagResource`
+ `UntagResource`
As seguintes ações somente de permissões são necessárias Conexões de código da AWS para concluir o handshake de autenticação:
+ `GetIndividualAccessToken`
+ `GetInstallationUrl`
+ `ListInstallationTargets`
+ `StartOAuthHandshake`
+ `UpdateConnectionInstallation`
A seguinte ação somente de permissões é necessária Conexões de código da AWS para usar uma conexão:
+ `UseConnection`
A seguinte ação somente de permissões é necessária Conexões de código da AWS para transmitir uma conexão a um serviço:
+ `PassConnection`
Para ver uma lista de AWS CodeStar notificações e AWS CodeConnections ações, consulte [Ações definidas por AWS CodeStar notificações](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_codestarnotifications.html#codestarnotifications-actions-as-permissions) e [Ações definidas por AWS CodeConnections](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_codestarconnections.html#codestarconnections-actions-as-permissions) no *Guia do usuário do IAM*.
### Recursos
AWS CodeStar Notificações e AWS CodeConnections não suportam a especificação de recursos ARNs em uma política.
### Chaves de condição
AWS CodeStar As notificações AWS CodeConnections definem seus próprios conjuntos de chaves de condição e também oferecem suporte ao uso de algumas chaves de condição globais. 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*.
Todas as ações de AWS CodeStar Notificações oferecem suporte à chave de `codestar-notifications:NotificationsForResource` condição. Para obter mais informações, consulte [Exemplos de políticas baseadas em identidade](security_iam_id-based-policy-examples.md).
Conexões de código da AWS defina as seguintes chaves de condição que podem ser usadas no `Condition` elemento de uma política do IAM. É possível usar essas chaves para refinar ainda mais as condições sob as quais a declaração de política se aplica. Para obter mais informações, consulte [AWS CodeConnections referência de permissões](security-iam.md#permissions-reference-connections).
| Chaves de condição | Description |
| --- | --- |
| `codeconnections:BranchName` | Filtra o acesso pelo nome da ramificação do repositório de terceiros. |
| `codeconnections:FullRepositoryId` | Filtra o acesso pelo repositório que é passado na solicitação. Aplica-se somente a solicitações UseConnection para acesso a um repositório específico |
| codeconnections:InstallationId | Filtra o acesso pelo ID de terceiros (como o ID de instalação da aplicação Bitbucket) que é usado para atualizar uma conexão. Permite restringir quais instalações de aplicações de terceiros podem ser usadas para estabelecer uma conexão |
| codeconnections:OwnerId | Filtra o acesso pelo proprietário ou ID da conta do provedor de terceiros |
| `codeconnections:PassedToService` | Filtra o acesso pelo serviço ao qual o principal tem permissão para passar uma conexão |
| `codeconnections:ProviderAction` | Filtra o acesso pela ação do provedor em uma solicitação UseConnection, como ListRepositories. |
| codeconnections:ProviderPermissionsRequired | Filtra o acesso pelo tipo de permissões de provedor de terceiros |
| `codeconnections:ProviderType` | Filtra o acesso pelo tipo de provedor de terceiros passado na solicitação |
| codeconnections:ProviderTypeFilter | Filtra o acesso pelo tipo de provedor de terceiros usado para filtrar resultados |
| codeconnections:RepositoryName | Filtra o acesso pelo nome do repositório de terceiros. |
### Exemplos
Para ver exemplos de AWS CodeStar notificações e políticas AWS CodeConnections baseadas em identidade, consulte. [Exemplos de políticas baseadas em identidade](security_iam_id-based-policy-examples.md)
## AWS CodeStar Notificações e políticas AWS CodeConnections baseadas em recursos
AWS CodeStar Notificações e AWS CodeConnections não oferecem suporte a políticas baseadas em recursos.
## Autorização baseada em tags do
Você pode anexar tags a AWS CodeStar notificações e AWS CodeConnections recursos ou passar tags em uma solicitação. 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 `codestar-notifications and codeconnections:ResourceTag/key-name`, `aws:RequestTag/key-name` ou chaves de condição `aws:TagKeys`. 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). Para obter mais informações sobre a marcação de AWS CodeStar notificações e AWS CodeConnections recursos, consulte[Recursos de conexões de tags](connections-tag.md).
Para visualizar exemplos de políticas baseadas em identidade para limitar o acesso a um recurso baseado em tags desse recurso, consulte [Usando tags para controlar o acesso aos AWS CodeConnections recursos](connections-tag-based-access-control.md).
## Perfis do IAM
Uma [função do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) é uma entidade dentro da sua AWS conta que tem permissões específicas.
### Usar credenciais temporárias
Você pode usar credenciais temporárias para fazer login com federação e assumir uma função do IAM ou uma função 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).
AWS CodeStar Notificações e AWS CodeConnections suporte ao uso de credenciais temporárias.
### 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.
AWS CodeStar As notificações oferecem suporte a funções vinculadas a serviços. Para obter detalhes sobre como criar ou gerenciar AWS CodeStar notificações e funções AWS CodeConnections vinculadas a serviços, consulte. [Usando funções vinculadas a serviços para notificações AWS CodeStar](using-service-linked-roles.md)
CodeConnections não oferece suporte a funções vinculadas a serviços.
## AWS CodeConnections referência de permissões
As tabelas a seguir listam cada operação de AWS CodeConnections 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 AWS CodeConnections APIs são agrupados em tabelas com base no escopo das ações permitidas por essa API. Consulte-o ao escrever 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 nas suas políticas de conexão, use as chaves de condição descritas aqui e listadas em [Chaves de condição](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys). Você também pode usar teclas de condição AWS-wide. 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 especificar uma ação, use o `codeconnections` prefixo seguido do nome da operação da API (por exemplo, `codeconnections:ListConnections` ou `codeconnections:CreateConnection`).
**Uso de curingas **
Para especificar várias ações ou recursos, use um caractere curinga (\$1) no seu ARN. Por exemplo, `codeconnections:*` especifica todas as AWS CodeConnections ações e `codeconnections:Get*` especifica todas as AWS CodeConnections 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 `MyConnection`.
```
arn:aws:codeconnections:us-west-2:account-ID:connection/*
```
Você pode usar curingas somente com os *connection* 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 *Manual do usuário do IAM*.
**Topics**
+ [Permissões para gerenciar conexões](#permissions-reference-connections-managing)
+ [Permissões para gerenciamento de hosts](#permissions-reference-connections-hosts)
+ [Permissões para concluir conexões](#permissions-reference-connections-handshake)
+ [Permissões para configurar hosts](#connections-permissions-actions-host-registration)
+ [Transmitir uma conexão para um serviço](#permissions-reference-connections-passconnection)
+ [Usar uma conexão](#permissions-reference-connections-use)
+ [Tipos de acesso suportados para `ProviderAction`](#permissions-reference-connections-access)
+ [Permissões compatíveis para marcar recursos de conexão](#permissions-reference-connections-tagging)
+ [Transmitir uma conexão a um link de repositório](#permissions-reference-connections-passrepository)
+ [Chave de condição compatível para links de repositório](#permissions-reference-connections-branch)
+ [Permissões suportadas para compartilhamento de conexão](#permissions-reference-connections-sharing)
### Permissões para gerenciar conexões
Uma função ou usuário designado para usar o SDK AWS CLI ou para visualizar, criar ou excluir conexões deve ter permissões limitadas ao seguinte.
**nota**
Não é possível concluir nem usar uma conexão no console somente com as permissões a seguir. É necessário adicionar as permissões em [Permissões para concluir conexões](#permissions-reference-connections-handshake).
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
```
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections permissões necessárias para gerenciar conexões**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| CreateConnection | `codeconnections:CreateConnection` Necessária para usar a CLI ou o console para criar uma conexão. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| DeleteConnection | `codeconnections:DeleteConnection` Necessária para usar a CLI ou o console para excluir uma conexão. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| GetConnection | `codeconnections:GetConnection` Necessária para usar a CLI ou o console para visualizar detalhes de uma conexão. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| ListConnections | `codeconnections:ListConnections` Necessária para usar a CLI ou o console para listar todas as conexões na conta. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Estas operações oferecem suporte às seguintes chaves de condição:
| Ação | Chaves de condição |
| --- | --- |
| `codeconnections:CreateConnection` | `codeconnections:ProviderType` |
| codeconnections:DeleteConnection | N/D |
| codeconnections:GetConnection | N/D |
| codeconnections:ListConnections | codeconnections:ProviderTypeFilter |
### Permissões para gerenciamento de hosts
Uma função ou usuário designado para usar o SDK AWS CLI ou para visualizar, criar ou excluir hosts deve ter permissões limitadas ao seguinte.
**nota**
Não é possível concluir nem usar uma conexão no host somente com as permissões a seguir. É necessário adicionar as permissões em [Permissões para configurar hosts](#connections-permissions-actions-host-registration).
```
codeconnections:CreateHost
codeconnections:DeleteHost
codeconnections:GetHost
codeconnections:ListHosts
```
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections permissões necessárias para gerenciar hosts**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| CreateHost | `codeconnections:CreateHost` Necessária para usar a CLI ou o console para criar um host. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| DeleteHost | `codeconnections:DeleteHost` Necessária para usar a CLI ou o console para excluir um host. | conexões de código: ::host/ *region* *account-id* *host-id* |
| GetHost | `codeconnections:GetHost` Necessária para usar a CLI ou o console para visualizar detalhes de um host. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| ListHosts | `codeconnections:ListHosts` Necessária para usar a CLI ou o console para listar todos os hosts na conta. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
Estas operações oferecem suporte às seguintes chaves de condição:
| Ação | Chaves de condição |
| --- | --- |
| `codeconnections:CreateHost` | `codeconnections:ProviderType` `codeconnections:VpcId` |
| codeconnections:DeleteHost | N/D |
| codeconnections:GetHost | N/D |
| codeconnections:ListHosts | codeconnections:ProviderTypeFilter |
Para ver um exemplo de política que usa a chave de **VpcId**condição, consulte[Exemplo: limite as permissões de VPC do host usando a **VpcId**chave de contexto](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-vpc).
### Permissões para concluir conexões
Uma função ou um usuário designado para gerenciar conexões no console deve ter as permissões necessárias para concluir uma conexão no console e criar uma instalação, o que inclui autorizar o handshake para o provedor e criar instalações para conexões a serem usadas. Use as permissões a seguir além das permissões acima.
As seguintes operações do IAM são usadas pelo console ao executar um handshake baseado em navegador. `ListInstallationTargets`, `GetInstallationUrl`, `StartOAuthHandshake`, `UpdateConnectionInstallation` e `GetIndividualAccessToken` são permissões de políticas do IAM. Elas não são ações de API.
```
codeconnections:GetIndividualAccessToken
codeconnections:GetInstallationUrl
codeconnections:ListInstallationTargets
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
```
Com base nisso, as permissões a seguir são necessárias para usar, criar, atualizar ou excluir uma conexão no console.
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
codeconnections:UseConnection
codeconnections:ListInstallationTargets
codeconnections:GetInstallationUrl
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
codeconnections:GetIndividualAccessToken
```
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections permissões necessárias para concluir conexões**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `GetIndividualAccessToken` | `codeconnections:GetIndividualAccessToken` Necessária para usar o console para concluir a conexão. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `GetInstallationUrl` | `codeconnections:GetInstallationUrl` Necessária para usar o console para concluir a conexão. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListInstallationTargets` | `codeconnections:ListInstallationTargets` Necessária para usar o console para concluir a conexão. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `StartOAuthHandshake` | `codeconnections:StartOAuthHandshake` Necessária para usar o console para concluir a conexão. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `UpdateConnectionInstallation` | `codeconnections:UpdateConnectionInstallation` Necessária para usar o console para concluir a conexão. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Estas operações oferecem suporte às chaves de condição a seguir.
| Ação | Chaves de condição |
| --- | --- |
| codeconnections:GetIndividualAccessToken | codeconnections:ProviderType |
| codeconnections:GetInstallationUrl | codeconnections:ProviderType |
| `codeconnections:ListInstallationTargets` | N/D |
| codeconnections:StartOAuthHandshake | codeconnections:ProviderType |
| codeconnections:UpdateConnectionInstallation | codeconnections:InstallationId |
### Permissões para configurar hosts
Uma função ou um usuário designado para gerenciar conexões no console deve ter as permissões necessárias para concluir uma conexão no console, o que inclui autorizar o handshake para o provedor e instalar a aplicação host. Use as permissões a seguir além das permissões para hosts acima.
As seguintes operações do IAM são usadas pelo console ao executar um registro de host baseado em navegador. `RegisterAppCode` e `StartAppRegistrationHandshake` são permissões de políticas do IAM. Elas não são ações de API.
```
codeconnections:RegisterAppCode
codeconnections:StartAppRegistrationHandshake
```
Com base nisso, as permissões a seguir são necessárias para usar, criar, atualizar ou excluir uma conexão no console que requer um host (como os tipos de provedor instalados).
```
codeconnections:CreateConnection
codeconnections:DeleteConnection
codeconnections:GetConnection
codeconnections:ListConnections
codeconnections:UseConnection
codeconnections:ListInstallationTargets
codeconnections:GetInstallationUrl
codeconnections:StartOAuthHandshake
codeconnections:UpdateConnectionInstallation
codeconnections:GetIndividualAccessToken
codeconnections:RegisterAppCode
codeconnections:StartAppRegistrationHandshake
```
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections permissões necessárias para concluir a configuração do host**
| Ações de conexões | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `RegisterAppCode` | `codeconnections:RegisterAppCode` Necessária para usar o console para concluir a configuração do host. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| `StartAppRegistrationHandshake` | `codeconnections:StartAppRegistrationHandshake` Necessária para usar o console para concluir a configuração do host. Esta é apenas uma permissão de política do IAM, e não uma ação de API. | arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
Estas operações oferecem suporte às chaves de condição a seguir.
### Transmitir uma conexão para um serviço
Quando uma conexão é passada para um serviço (por exemplo, quando um ARN de conexão é fornecido em uma definição de pipeline para criar ou atualizar um pipeline), o usuário deve ter a `codeconnections:PassConnection` permissão.
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections permissões necessárias para passar uma conexão**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `PassConnection` | `codeconnections:PassConnection` Necessária para passar uma conexão para um serviço. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Esta operação também é compatível com a seguinte chave de condição:
+ `codeconnections:PassedToService`
**Valores compatíveis com chaves de condição**
| Chave | Provedores de ação válidos |
| --- | --- |
| `codeconnections:PassedToService` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/dtconsole/latest/userguide/security-iam.html) |
### Usar uma conexão
Quando um serviço como CodePipeline usa uma conexão, a função de serviço deve ter a `codeconnections:UseConnection` permissão para uma determinada conexão.
Para gerenciar conexões no console, a política do usuário deve ter a permissão `codeconnections:UseConnection`.
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections ação necessária para usar conexões**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `UseConnection` | `codeconnections:UseConnection` Necessária para usar uma conexão. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Esta operação também é compatível com as seguintes chaves de condição:
+ `codeconnections:BranchName`
+ `codeconnections:FullRepositoryId`
+ `codeconnections:OwnerId`
+ `codeconnections:ProviderAction`
+ `codeconnections:ProviderPermissionsRequired`
+ `codeconnections:RepositoryName`
**Valores compatíveis com chaves de condição**
| Chave | Provedores de ação válidos |
| --- | --- |
| `codeconnections:FullRepositoryId` | O nome do usuário e o nome de um repositório, como `my-owner/my-repository`. Compatível somente quando a conexão está sendo usada para acessar um repositório específico. |
| `codeconnections:ProviderPermissionsRequired` | read\$1only ou read\$1write |
| `codeconnections:ProviderAction` | `GetBranch`, `ListRepositories`, `ListOwners`, `ListBranches`, `StartUploadArchiveToS3`, `GitPush`, `GitPull`, `GetUploadArchiveToS3Status`, `CreatePullRequestDiffComment`, `GetPullRequest`, `ListBranchCommits`, `ListCommitFiles`, `ListPullRequestComments`, `ListPullRequestCommits`. Para obter mais informações, consulte a próxima seção. |
As chaves de condição necessárias para algumas funcionalidades podem mudar ao longo do tempo. Recomendamos que você use `codeconnections:UseConnection` para controlar o acesso a uma conexão, a menos que seus requisitos de controle de acesso exijam permissões diferentes.
### Tipos de acesso suportados para `ProviderAction`
Quando uma conexão é usada por um AWS serviço, isso resulta na realização de chamadas de API para seu provedor de código-fonte. Por exemplo, um serviço pode listar repositórios para uma conexão Bitbucket chamando a `https://api.bitbucket.org/2.0/repositories/username` API.
A chave de `ProviderAction` condição permite que você restrinja qual APIs provedor pode ser chamado. Como o caminho da API pode ser gerado dinamicamente e o caminho varia de provedor para provedor, o valor `ProviderAction` é mapeado em um nome de ação abstrata em vez do URL da API. Isso permite que você escreva políticas que têm o mesmo efeito, independentemente do tipo de provedor para a conexão.
A seguir estão os tipos de acesso concedidos para cada um dos valores `ProviderAction` compatíveis: A seguir são mostradas permissões de políticas do IAM. Elas não são ações de API.
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections tipos de acesso suportados para `ProviderAction`**
| AWS CodeConnections permissão | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `GetBranch` | ` codeconnections:GetBranch` Necessária para acessar informações sobre uma ramificação, como a confirmação mais recente para essa ramificação | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListRepositories` | ` codeconnections:ListRepositories` Necessária para acessar uma lista de repositórios públicos e privados, incluindo detalhes sobre esses repositórios, que pertencem a um proprietário. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListOwners` | `codeconnections:ListOwners` Necessária para acessar uma lista de proprietários aos quais a conexão tem acesso. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListBranches` | ` codeconnections:ListBranches` Necessária para acessar a lista de ramificações que existem em um determinado repositório. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `StartUploadArchiveToS3` | ` codeconnections:StartUploadArchiveToS3` Necessária para ler o código-fonte e fazer seu upload para o Amazon S3. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `GitPush` | ` codeconnections:GitPush` Necessária para gravar em um repositório usando o Git. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `GitPull` | ` codeconnections:GitPull` Necessária para ler de um repositório usando o Git. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| GetUploadArchiveToS3Status | ` codeconnections:GetUploadArchiveToS3Status` Necessária para acessar o status de um upload, incluindo quaisquer mensagens de erro, iniciado por `StartUploadArchiveToS3`. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| CreatePullRequestDiffComment | ` codeconnections:CreatePullRequestDiffComment` Necessária para acessar comentários em uma solicitação pull. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| GetPullRequest | ` codeconnections:GetPullRequest` Necessária para visualizar solicitações pull para um repositório. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListBranchCommits` | ` codeconnections:ListBranchCommits` Necessária para visualizar uma lista de confirmações para uma ramificação de repositório. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListCommitFiles` | ` codeconnections:ListCommitFiles` Necessária para visualizar uma lista de arquivos para uma confirmação. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListPullRequestComments` | ` codeconnections:ListPullRequestComments` Necessária para visualizar uma lista de comentários para uma solicitação pull. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
| `ListPullRequestCommits` | ` codeconnections:ListPullRequestCommits` Necessária para visualizar uma lista de confirmações para uma solicitação pull. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
### Permissões compatíveis para marcar recursos de conexão
As operações do IAM a seguir são usadas na marcação de recursos de conexão.
```
codeconnections:ListTagsForResource
codeconnections:TagResource
codeconnections:UntagResource
```
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections ações necessárias para marcar recursos de conexão**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `ListTagsForResource` | `codeconnections:ListTagsForResource` Necessária para visualizar uma lista de tags associadas ao recurso de conexão. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id*,arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| `TagResource` | `codeconnections:TagResource` Necessária para marcar um recurso de conexão. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id*,arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
| `UntagResource` | `codeconnections:UntagResource` Necessária para remover tags de um recurso de conexão. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id*,arn:aws:codeconnections: ::host/ *region* *account-id* *host-id* |
### Transmitir uma conexão a um link de repositório
Quando um link de repositório é fornecido em uma configuração de sincronização, o usuário deve ter a permissão `codeconnections:PassRepository` para o ARN/recurso do link de repositório.
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections permissões necessárias para passar uma conexão**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `PassRepository` | `codeconnections:PassRepository` Necessário para transmitir um link de repositório para uma configuração de sincronização. | arn:aws:codeconnections: ::repository-link/ *region* *account-id* *repository-link-id* |
Esta operação também é compatível com a seguinte chave de condição:
+ `codeconnections:PassedToService`
**Valores compatíveis com chaves de condição**
| Chave | Provedores de ação válidos |
| --- | --- |
| `codeconnections:PassedToService` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/dtconsole/latest/userguide/security-iam.html) |
### Chave de condição compatível para links de repositório
As operações para links de repositório e recursos de configuração de sincronização são compatíveis com a seguinte chave de condição:
+ `codeconnections:Branch`
Filtra o acesso pelo nome da ramificação que é passado na solicitação.
**Ações compatíveis com a chave de condição**
| Chave | Valores válidos |
| --- | --- |
| `codeconnections:Branch` | As seguintes ações são compatíveis com essa chave de condição:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/dtconsole/latest/userguide/security-iam.html) |
### Permissões suportadas para compartilhamento de conexão
As seguintes operações do IAM são usadas ao compartilhar conexões.
```
codeconnections:GetResourcePolicy
```
Use as barras de rolagem para ver o restante da tabela.
**AWS CodeConnections ações necessárias para compartilhar conexões**
| AWS CodeConnections ações | Permissões obrigatórias | Recursos |
| --- | --- | --- |
| `GetResourcePolicy` | `codeconnections:GetResourcePolicy` Necessário para acessar informações sobre a política de recursos. | arn:aws:codeconnections: ::connection/ *region* *account-id* *connection-id* |
Para obter mais informações sobre compartilhamento de conexão, consulte[Compartilhe conexões com Contas da AWS](connections-share.md).
# Exemplos de políticas baseadas em identidade
Por padrão, os usuários e funções do IAM que têm uma das políticas gerenciadas para AWS CodeCommit AWS CodeBuild AWS CodeDeploy,, ou AWS CodePipeline aplicada têm permissões para conexões, notificações e regras de notificação que se alinham à intenção dessas políticas. Por exemplo, usuários ou funções do IAM que têm uma das políticas de acesso total (**AWSCodeCommitFullAccess**AWSCodeBuildAdminAccess****, **AWSCodeDeployFullAccess**, ou **AWSCodePipeline\$1FullAccess**) aplicada a eles também têm acesso total às notificações e às regras de notificação criadas para os recursos desses serviços.
Outros usuários e funções do IAM não têm permissão para criar ou modificar AWS CodeStar notificações e AWS CodeConnections recursos. 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 a usuários e funções permissão para executar operações da API nos recursos necessários especificados. O administrador deve anexar essas políticas aos usuários ou grupos do IAM que exigem essas permissões.
# Permissões e exemplos de AWS CodeStar notificações
As declarações e exemplos de políticas a seguir podem ajudar você a gerenciar AWS CodeStar as notificações.
## Permissões relacionadas a notificações em políticas gerenciadas de acesso total
As políticas **AWSCodeCommitFullAccess**AWSCodeBuildAdminAccess****, **AWSCodeDeployFullAccess**, e **AWSCodePipeline\$1FullAccess**gerenciadas incluem as seguintes declarações para permitir acesso total às notificações no console do Developer Tools. Os usuários com uma dessas políticas gerenciadas aplicadas também podem criar e gerenciar tópicos do Amazon SNS para notificações, inscrever e cancelar a inscrição de usuários em tópicos e listar tópicos para escolher como destinos para regras de notificação.
**nota**
Na política gerenciada, a chave de condição `codestar-notifications:NotificationsForResource` terá um valor específico para o tipo de recurso do serviço. Por exemplo, na política de acesso total para CodeCommit, o valor é`arn:aws:codecommit:*`.
```
{
"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::*"}
}
},
{
"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": "SNSTopicListAccess",
"Effect": "Allow",
"Action": [
"sns:ListTopics"
],
"Resource": "*"
},
{
"Sid": "CodeStarNotificationsChatbotAccess",
"Effect": "Allow",
"Action": [
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:ListMicrosoftTeamsChannelConfigurations"
],
"Resource": "*"
}
```
## Permissões relacionadas a notificações em políticas gerenciadas somente leitura
As políticas **AWSCodeCommitReadOnlyAccess**AWSCodeBuildReadOnlyAccess****,, **AWSCodeDeployReadOnlyAccess**, e **AWSCodePipeline\$1ReadOnlyAccess**gerenciadas incluem as seguintes declarações para permitir acesso somente para leitura às notificações. Por exemplo, elas podem exibir notificações de recursos no console do Developer Tools, mas não podem criar, gerenciar ou se inscrever neles.
**nota**
Na política gerenciada, a chave de condição `codestar-notifications:NotificationsForResource` terá um valor específico para o tipo de recurso do serviço. Por exemplo, na política de acesso total para CodeCommit, o valor é`arn:aws:codecommit:*`.
```
{
"Sid": "CodeStarNotificationsPowerUserAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:DescribeNotificationRule"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws::*"}
}
},
{
"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
As políticas **AWSCodeBuildDeveloperAccess**gerenciadas **AWSCodeCommitPowerUser**AWSCodeBuildDeveloperAccess****,, e incluem as seguintes declarações para permitir que os desenvolvedores com uma dessas políticas gerenciadas aplicadas criem, editem e assinem notificações. Elas não podem excluir regras de notificação ou gerenciar tags para recursos.
**nota**
Na política gerenciada, a chave de condição `codestar-notifications:NotificationsForResource` terá um valor específico para o tipo de recurso do serviço. Por exemplo, na política de acesso total para CodeCommit, o valor é`arn:aws:codecommit:*`.
```
{
"Sid": "CodeStarNotificationsReadWriteAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe"
],
"Resource": "*",
"Condition" : {
"StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws::*"}
}
},
{
"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": "*"
}
```
## Exemplo: uma política em nível de administrador para gerenciar notificações AWS CodeStar
Neste exemplo, você quer conceder a um usuário do IAM em sua AWS conta acesso total às AWS CodeStar notificações para que o usuário possa revisar os detalhes das regras de notificação e listar as regras de notificação, os alvos e os tipos de eventos. Você também deseja permitir que o usuário adicione, atualize e exclua regras de notificação. Essa é uma política de acesso total, equivalente às permissões de notificação incluídas como parte das políticas **AWSCodeBuildAdminAccess**AWSCodeCommitFullAccess****, **AWSCodeDeployFullAccess**, e **AWSCodePipeline\$1FullAccess**gerenciadas. Como essas políticas gerenciadas, você só deve anexar esse tipo de declaração de política a usuários, grupos ou funções do IAM que exijam acesso administrativo total às notificações e regras de notificação em toda a sua AWS conta.
**nota**
Essa política contém a permissão `CreateNotificationRule`. Qualquer usuário com essa política aplicada ao usuário ou função do IAM poderá criar regras de notificação para todo e qualquer tipo de recurso suportado pelas AWS CodeStar notificações na AWS conta, mesmo que esse usuário não tenha acesso a esses recursos. Por exemplo, um usuário com essa política pode criar uma regra de notificação para um CodeCommit repositório sem ter permissões para acessar a CodeCommit si mesmo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AWSCodeStarNotificationsFullAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DeleteNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:ListNotificationRules",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe",
"codestar-notifications:DeleteTarget",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource",
"codestar-notifications:TagResource",
"codestar-notifications:UntagResource"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: uma política em nível de colaborador para o uso de notificações AWS CodeStar
Neste exemplo, você deseja conceder acesso ao day-to-day uso de AWS CodeStar notificações, como criar e assinar notificações, mas não a ações mais destrutivas, como excluir regras ou alvos de notificação. Isso equivale ao acesso fornecido nas políticas **AWSCodeCommitPowerUser**gerenciadas **AWSCodeBuildDeveloperAccess**AWSCodeDeployDeveloperAccess****, e.
**nota**
Essa política contém a permissão `CreateNotificationRule`. Qualquer usuário com essa política aplicada ao usuário ou função do IAM poderá criar regras de notificação para todo e qualquer tipo de recurso suportado pelas AWS CodeStar notificações na AWS conta, mesmo que esse usuário não tenha acesso a esses recursos. Por exemplo, um usuário com essa política pode criar uma regra de notificação para um CodeCommit repositório sem ter permissões para acessar a CodeCommit si mesmo.
```
{
"Version": "2012-10-17",
"Sid": "AWSCodeStarNotificationsPowerUserAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:CreateNotificationRule",
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:ListNotificationRules",
"codestar-notifications:UpdateNotificationRule",
"codestar-notifications:Subscribe",
"codestar-notifications:Unsubscribe",
"codestar-notifications:ListTargets",
"codestar-notifications:ListTagsforResource"
],
"Resource": "*"
}
]
}
```
## Exemplo: uma read-only-level política para usar AWS CodeStar notificações
Neste exemplo, você deseja conceder a um usuário do IAM em sua conta acesso somente leitura a regras de notificação, destinos e tipos de evento em sua conta da AWS . Este exemplo mostra como você pode criar uma política que permite visualizar esses itens. Isso equivale às permissões incluídas como parte das **AWSCodeBuildReadOnlyAccess**políticas **AWSCodePipeline\$1ReadOnlyAccess**gerenciadas e. **AWSCodeCommitReadOnly**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "CodeNotificationforReadOnly",
"Statement": [
{
"Sid": "ReadsAccess",
"Effect": "Allow",
"Action": [
"codestar-notifications:DescribeNotificationRule",
"codestar-notifications:ListNotificationRules",
"codestar-notifications:ListTargets",
"codestar-notifications:ListEventTypes"
],
"Resource": "*"
}
]
}
```
------
# Permissões e exemplos para Conexões de código da AWS
As declarações de políticas e os exemplos a seguir podem ajudar você a gerenciar o Conexões de código da AWS.
Para obter informações sobre como criar uma política baseada em identidade do IAM usando esses documentos de política JSON de exemplo, consulte [Criação de políticas na guia JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor) no *Manual do usuário do IAM*.
## Exemplo: uma política para criar Conexões de código da AWS com a CLI e visualizar com o console
Uma função ou usuário designado para usar o SDK AWS CLI ou para visualizar, criar, marcar ou excluir conexões deve ter permissões limitadas ao seguinte.
**nota**
Não é possível concluir uma conexão no console somente com as permissões a seguir. É necessário adicionar as permissões na próxima seção.
Para usar o console a fim de visualizar uma lista de conexões disponíveis, visualizar tags e usar uma conexão, use a política a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ConnectionsFullAccess",
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:DeleteConnection",
"codeconnections:UseConnection",
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:TagResource",
"codeconnections:ListTagsForResource",
"codeconnections:UntagResource"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: uma política para criar Conexões de código da AWS com o console
Uma função ou um usuário designado para gerenciar conexões no console deve ter as permissões necessárias para concluir uma conexão no console e criar uma instalação, o que inclui autorizar o handshake para o provedor e criar instalações para conexões a serem usadas. `UseConnection` também deve ser adicionada para usar a conexão no console. Use a política a seguir para visualizar, usar, criar, marcar ou excluir uma conexão no console.
**nota**
A partir de 1º de julho de 2024, o console cria conexões com o `codeconnections` ARN do recurso. Os recursos com os dois prefixos de serviço continuarão sendo exibidos no console.
**nota**
Para recursos criados usando o console, as ações da declaração de política devem ser incluídas `codestar-connections` como prefixo do serviço, conforme mostrado no exemplo a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codestar-connections:CreateConnection",
"codestar-connections:DeleteConnection",
"codestar-connections:GetConnection",
"codestar-connections:ListConnections",
"codestar-connections:GetInstallationUrl",
"codestar-connections:GetIndividualAccessToken",
"codestar-connections:ListInstallationTargets",
"codestar-connections:StartOAuthHandshake",
"codestar-connections:UpdateConnectionInstallation",
"codestar-connections:UseConnection",
"codestar-connections:TagResource",
"codestar-connections:ListTagsForResource",
"codestar-connections:UntagResource"
],
"Resource": [
"*"
]
}
]
}
```
------
## Exemplo: uma política em nível de administrador para gerenciar Conexões de código da AWS
Neste exemplo, você deseja conceder acesso total a um usuário do IAM em sua AWS conta para que ele CodeConnections possa adicionar, atualizar e excluir conexões. Essa é uma política de acesso total, equivalente à política **AWSCodePipeline\$1FullAccess**gerenciada. Assim como essa política gerenciada, você só deve anexar esse tipo de declaração de política a usuários, grupos ou funções do IAM que exijam acesso administrativo total às conexões em sua AWS conta.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ConnectionsFullAccess",
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:DeleteConnection",
"codeconnections:UseConnection",
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:ListInstallationTargets",
"codeconnections:GetInstallationUrl",
"codeconnections:StartOAuthHandshake",
"codeconnections:UpdateConnectionInstallation",
"codeconnections:GetIndividualAccessToken",
"codeconnections:TagResource",
"codeconnections:ListTagsForResource",
"codeconnections:UntagResource"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: uma política em nível de colaborador para usar Conexões de código da AWS
Neste exemplo, você deseja conceder acesso ao day-to-day uso de CodeConnections, como criar e visualizar detalhes de conexões, mas não a ações mais destrutivas, como excluir conexões.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AWSCodeConnectionsPowerUserAccess",
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:UseConnection",
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:ListInstallationTargets",
"codeconnections:GetInstallationUrl",
"codeconnections:GetIndividualAccessToken",
"codeconnections:StartOAuthHandshake",
"codeconnections:UpdateConnectionInstallation",
"codeconnections:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: uma read-only-level política para usar Conexões de código da AWS
Neste exemplo, você quer conceder a um usuário do IAM em sua conta acesso somente de leitura às conexões em sua AWS conta. Este exemplo mostra como você pode criar uma política que permite visualizar esses itens.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "ConnectionsforReadOnly",
"Statement": [
{
"Sid": "ReadsAPIAccess",
"Effect": "Allow",
"Action": [
"codeconnections:GetConnection",
"codeconnections:ListConnections",
"codeconnections:ListInstallationTargets",
"codeconnections:GetInstallationUrl",
"codeconnections:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
## Exemplo: limite as permissões de VPC do host usando a **VpcId**chave de contexto
No exemplo a seguir, o cliente pode usar a chave de **VpcId**contexto para limitar a criação ou o gerenciamento de hosts a hosts com VPC especificada.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"codeconnections:CreateHost",
"codeconnections:UpdateHost"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"codeconnections:VpcId": "vpc-EXAMPLE"
}
}
}
]
}
```
------
# Usando tags para controlar o acesso aos AWS CodeConnections recursos
As tags podem ser anexadas ao recurso ou passadas na solicitação para serviços compatíveis com tags. Em AWS CodeConnections, os recursos podem ter tags e algumas ações podem incluir tags. Ao criar uma política do IAM, você poderá usar chaves de condição de tag para controlar o seguinte:
+ Quais usuários podem executar ações em um recurso de pipeline, com base nas tags que o recurso já tem.
+ Quais tags podem ser transmitidas na solicitação de uma ação.
+ Se chaves de tags específicas podem ser usadas em uma solicitação.
Os exemplos a seguir demonstram como especificar condições de tag nas políticas para AWS CodeConnections usuários.
**Example 1: Permitir ações com base em tags na solicitação**
A política a seguir concede aos usuários permissão para criar conexões em AWS CodeConnections.
Para fazer isso, ela permitirá as ações `CreateConnection` e `TagResource` se a solicitação especificar uma tag denominada `Project` com o valor `ProjectA`. (A `aws:RequestTag` chave de condição é usada para controlar quais tags podem ser transmitidas em uma solicitação do IAM.) A `aws:TagKeys` condição garante que a chave de tag faça diferenciação de letras maiúsculas e minúsculas.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:TagResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/Project": "ProjectA"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Project"]
}
}
}
]
}
```
**Example 2: Permitir ações com base em tags de recursos**
A política a seguir concede aos usuários permissão para executar ações e receber informações sobre recursos no AWS CodeConnections.
Para fazer isso, ela permitirá ações específicas se o pipeline tiver uma tag denominada `Project` com o valor `ProjectA`. (A `aws:RequestTag` chave de condição é usada para controlar quais tags podem ser transmitidas em uma solicitação do IAM.) A `aws:TagKeys` condição garante que a chave de tag faça diferenciação de letras maiúsculas e minúsculas.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codeconnections:CreateConnection",
"codeconnections:DeleteConnection",
"codeconnections:ListConnections"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Project": "ProjectA"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Project"]
}
}
}
]
}
```
## Uso de notificações e conexões no console
A experiência de notificações é incorporada aos CodePipeline consoles CodeBuild CodeCommit, CodeDeploy,, e, bem como no console de Ferramentas do Desenvolvedor, na própria barra de navegação de **Configurações**. Para acessar notificações nos consoles, é necessário ter uma das políticas gerenciadas para esses serviços aplicada ou um conjunto mínimo de permissões. Essas permissões devem permitir que você liste e visualize detalhes sobre as AWS CodeStar notificações e AWS CodeConnections os recursos em sua AWS conta. 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 obter mais informações sobre como conceder acesso a AWS CodeBuild, AWS CodeCommit, e AWS CodeDeploy AWS CodePipeline, incluindo acesso a esses consoles, consulte os tópicos a seguir:
+ CodeBuild: [Usando políticas baseadas em identidade](https://docs.aws.amazon.com/codebuild/latest/userguide/security_iam_id-based-policy-examples.html#managed-policies) para CodeBuild
+ CodeCommit: [Usando políticas baseadas em identidade](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control-iam-identity-based-access-control.html) para CodeCommit
+ AWS CodeDeploy: [Gerenciamento de identidade e acesso para AWS CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/security-iam.html)
+ CodePipeline: [Controle de acesso com políticas do IAM](https://docs.aws.amazon.com/codepipeline/latest/userguide/access-control.html)
AWS CodeStar As notificações não têm nenhuma política AWS gerenciada. Para fornecer acesso à funcionalidade de notificação, é necessário aplicar uma das políticas gerenciadas a um dos serviços listados anteriormente ou criar políticas com o nível de permissão que deseja conceder a usuários ou entidades e anexar essas políticas aos usuários, aos grupos ou às funções que exigem essas permissões. Para obter mais informações e exemplo, consulte o seguinte:
+ [Exemplo: uma política em nível de administrador para gerenciar notificações AWS CodeStar](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-full-access)
+ [Exemplo: uma política em nível de colaborador para o uso de notificações AWS CodeStar](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-contributor)
+ [Exemplo: uma read-only-level política para usar AWS CodeStar notificações](security_iam_id-based-policy-examples-notifications.md#security_iam_id-based-policy-examples-notifications-read-only).
AWS CodeConnections não tem nenhuma política AWS gerenciada. Você usa as permissões e combinações de permissões para acesso, como as permissões detalhadas em [Permissões para concluir conexões](#permissions-reference-connections-handshake).
Para saber mais, consulte:
+ [Exemplo: uma política em nível de administrador para gerenciar Conexões de código da AWS](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-fullaccess)
+ [Exemplo: uma política em nível de colaborador para usar Conexões de código da AWS](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-contributor)
+ [Exemplo: uma read-only-level política para usar Conexões de código da AWS](security_iam_id-based-policy-examples-connections.md#security_iam_id-based-policy-examples-connections-readonly)
Você não precisa permitir permissões de 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": "*"
}
]
}
```
# AWS CodeStar Notificações de solução de problemas, AWS CodeConnections identidade e acesso
Use as seguintes informações para ajudar a diagnosticar e corrigir problemas comuns que podem ser encontrados ao trabalhar com notificações e o IAM.
**Topics**
+ [Sou administrador e quero permitir que outros usuários tenham acesso a notificações](#security_iam_troubleshoot-admin-delegate)
+ [Criei um tópico do Amazon SNS e o adicionei como um destino de regra de notificação, mas não estou recebendo e-mails sobre eventos](#security_iam_troubleshoot-sns)
+ [Quero permitir que pessoas fora da minha AWS conta acessem minhas AWS CodeStar notificações e AWS CodeConnections recursos](#security_iam_troubleshoot-cross-account-access)
## Sou administrador e quero permitir que outros usuários tenham acesso a notificações
Para permitir que outras pessoas acessem as AWS CodeStar Notificações AWS CodeConnections, 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. Em seguida, você deve anexar uma política à entidade que conceda a ela as permissões corretas em AWS CodeStar Notificações AWS CodeConnections e. 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*.
Para obter informações específicas sobre AWS CodeStar notificações, consulte[Permissões e exemplos de AWS CodeStar notificações](security_iam_id-based-policy-examples-notifications.md).
## Criei um tópico do Amazon SNS e o adicionei como um destino de regra de notificação, mas não estou recebendo e-mails sobre eventos
Para receber notificações sobre eventos, você deve ter um tópico do Amazon SNS válido inscrito como um destino para a regra de notificação, e seu endereço de e-mail deve estar inscrito no tópico do Amazon SNS. Para solucionar problemas com o tópico do Amazon SNS, verifique o seguinte:
+ Certifique-se de que o tópico do Amazon SNS esteja na mesma AWS região da regra de notificação.
+ Verifique se o seu alias de e-mail está inscrito no tópico correto e se você confirmou a assinatura. Para obter mais informações, consulte [Como inscrever um endpoint em um tópico do Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-tutorial-create-subscribe-endpoint-to-topic.html).
+ Verifique se a política do tópico foi modificada para permitir que AWS CodeStar as notificações enviem notificações para esse tópico. A política do tópico deve incluir uma declaração semelhante à seguinte:
```
{
"Sid": "AWSCodeStarNotifications_publish",
"Effect": "Allow",
"Principal": {
"Service": [
"codestar-notifications.amazonaws.com"
]
},
"Action": "SNS:Publish",
"Resource": "arn:aws:sns:us-east-1:123456789012:MyNotificationTopicName",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
```
Para obter mais informações, consulte [Configurar](setting-up.md).
## Quero permitir que pessoas fora da minha AWS conta acessem minhas AWS CodeStar notificações e AWS CodeConnections recursos
É possível criar um perfil que os usuários de outras contas ou pessoas fora da organização podem usar para acessar seus recursos. É possível especificar quem é confiável para assumir o perfil. Para serviços que oferecem suporte a políticas baseadas em recursos ou listas de controle de acesso (ACLs), você pode usar essas políticas para conceder às pessoas acesso aos seus recursos.
Para saber mais, consulte:
+ Para saber se AWS CodeStar as Notificações AWS CodeConnections oferecem suporte a esses recursos, consulte[Como os recursos no console do Developer Tools funcionam com o IAM](security_iam_service-with-iam.md).
+ Para saber como fornecer acesso aos seus recursos em todos os Contas da AWS que você possui, consulte Como [fornecer acesso a um usuário do IAM em outro Conta da AWS que você possui](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) no *Guia do usuário do IAM*.
+ Para saber como fornecer acesso aos seus recursos a terceiros Contas da AWS, consulte Como [fornecer acesso Contas da AWS a terceiros](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html) no *Guia do usuário do IAM*.
+ Para saber como conceder acesso por meio da federação de identidades, consulte [Conceder acesso a usuários autenticados externamente (federação de identidades)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html) no *Guia do usuário do IAM*.
+ Para conhecer a diferença entre perfis e políticas baseadas em recurso para acesso entre contas, consulte [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*.
# Usando funções vinculadas a serviços para notificações AWS CodeStar
AWS CodeStar As notificações usam AWS Identity and Access Management 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) (IAM). Uma função vinculada ao serviço é um tipo exclusivo de função do IAM vinculada diretamente às AWS CodeStar Notificações. As funções vinculadas ao serviço são predefinidas pelas AWS CodeStar Notificações e incluem todas as permissões que o serviço exige para chamar outros AWS serviços em seu nome. Essa função é criada na primeira vez que você cria uma regra de notificação. Não é necessário criar a função.
Uma função vinculada ao serviço facilita a configuração das AWS CodeStar notificações porque você não precisa adicionar permissões manualmente. AWS CodeStar As notificações definem as permissões de suas funções vinculadas ao serviço e, a menos que definido de outra forma, somente AWS CodeStar as notificações podem assumir suas funções. As permissões definidas incluem a política de confiança e a política de permissões, que não pode ser anexada a nenhuma outra entidade do IAM.
Para excluir uma função vinculada ao serviço, primeiro é necessário excluir os recursos relacionados. Isso protege seus recursos de AWS CodeStar notificações porque você não pode remover inadvertidamente a permissão para acessar os recursos.
Para obter informações sobre outros produtos que oferecem suporte a funções vinculadas a serviços, consulte [Serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
## Permissões de função vinculadas ao serviço para notificações AWS CodeStar
AWS CodeStar As notificações usam a função AWSService RoleForCodeStarNotifications vinculada ao serviço para recuperar informações sobre eventos que ocorrem em sua cadeia de ferramentas e enviar notificações para os alvos que você especificar.
A função AWSService RoleForCodeStarNotifications vinculada ao serviço confia nos seguintes serviços para assumir a função:
+ `codestar-notifications.amazonaws.com`
A política de permissões de função permite que AWS CodeStar as notificações concluam as seguintes ações nos recursos especificados:
+ Ação: `PutRule` em `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Ação: `DescribeRule` em `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Ação: `PutTargets` em `CloudWatch Event rules that are named awscodestar-notifications-*`
+ Ação: `CreateTopic` para `create Amazon SNS topics for use with AWS CodeStar Notifications with the prefix CodeStarNotifications-`
+ Ação: `GetCommentsForPullRequests` em `all comments on all pull requests in all CodeCommit repositories in the AWS account`
+ Ação: `GetCommentsForComparedCommit` em `all comments on all commits in all CodeCommit repositories in the AWS account`
+ Ação: `GetDifferences` em `all commits in all CodeCommit repositories in the AWS account`
+ Ação: `GetCommentsForComparedCommit` em `all comments on all commits in all CodeCommit repositories in the AWS account`
+ Ação: `GetDifferences` em `all commits in all CodeCommit repositories in the AWS account`
+ Ação: `DescribeSlackChannelConfigurations` em `all AWS Chatbot clients in the AWS account`
+ Ação: `UpdateSlackChannelConfiguration` em `all AWS Chatbot clients in the AWS account`
+ Ação: `ListActionExecutions` em `all actions in all pipelines in the AWS account`
+ Ação: `GetFile` em `all files in all CodeCommit repositories in the AWS account unless otherwise tagged`
Você pode ver essas ações na declaração de política da função AWSService RoleForCodeStarNotifications vinculada ao serviço.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"events:PutTargets",
"events:PutRule",
"events:DescribeRule"
],
"Resource": "arn:aws:events:*:*:rule/awscodestarnotifications-*",
"Effect": "Allow"
},
{
"Action": [
"sns:CreateTopic"
],
"Resource": "arn:aws:sns:*:*:CodeStarNotifications-*",
"Effect": "Allow"
},
{
"Action": [
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommentsForComparedCommit",
"codecommit:GetDifferences",
"chatbot:DescribeSlackChannelConfigurations",
"chatbot:UpdateSlackChannelConfiguration",
"codepipeline:ListActionExecutions"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"codecommit:GetFile"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:ResourceTag/ExcludeFileContentFromNotifications": "true"
}
},
"Effect": "Allow"
}
]
}
```
------
Você deve configurar permissões para que uma entidade do IAM (por exemplo, um usuário, grupo ou função) crie, edite ou exclua um perfil vinculado a serviço. Para saber mais, consulte [Permissões de Função Vinculadas ao Serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) no *Guia do Usuário do IAM*.
## Criação de uma função vinculada ao serviço para Notificações AWS CodeStar
Não é necessário criar manualmente um perfil vinculado ao serviço. Você pode usar o console do Developer Tools ou a CreateNotificationRule API do AWS CLI ou SDKs para criar uma regra de notificação. Você também pode chamar a API diretamente. Independentemente do método usado, a função vinculada ao serviço é criada para você.
Se excluir esse perfil vinculado ao serviço e precisar criá-lo novamente, será possível usar esse mesmo processo para recriar o perfil em sua conta. Você pode usar o console do Developer Tools ou a CreateNotificationRule API do AWS CLI ou SDKs para criar uma regra de notificação. Você também pode chamar a API diretamente. Independentemente do método usado, a função vinculada ao serviço é criada para você.
## Editando uma função vinculada ao serviço para Notificações AWS CodeStar
Depois que criar uma função vinculada ao serviço, você não poderá alterar o nome da função, pois várias entidades podem fazer referência a ela. No entanto, é possível usar o IAM para editar a descrição da função. Para saber mais, consulte [Editar uma função vinculada a serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) no *Guia do usuário do IAM*.
## Excluindo uma função vinculada ao serviço para Notificações AWS CodeStar
Se você não precisar mais usar um recurso ou serviço que requer uma função vinculada a serviço, é recomendável excluí-la. Dessa forma, você não tem uma entidade não utilizada que não seja monitorada ativamente ou mantida. É necessário limpar os recursos de sua função vinculada ao serviço antes de excluí-la. Para AWS CodeStar notificações, isso significa excluir todas as regras de notificação que usam a função de serviço em sua AWS conta.
**nota**
Se o serviço de AWS CodeStar Notificações estiver usando a função quando você tentar excluir os recursos, a exclusão poderá falhar. Se isso acontecer, espere alguns minutos e tente a operação novamente.
**Para excluir recursos de AWS CodeStar notificações usados pelo AWSService RoleForCodeStarNotifications**
1. Abra o console do AWS Developer Tools em [https://console.aws.amazon.com/codesuite/configurações/notificações](https://console.aws.amazon.com/codesuite/settings/notifications/).
**nota**
As regras de notificação se aplicam à AWS região em que foram criadas. Se você tiver regras de notificação em mais de uma AWS região, use o seletor de região para alterar o. Região da AWS
1. Escolha todas as regras de notificação que aparecem na lista e escolha **Delete (Excluir)**.
1. Repita essas etapas em todas as AWS regiões em que você criou as regras de notificação.
**Para **usar o IAM** para excluir a função vinculada ao serviço **
Use o console do IAM ou AWS CLI a AWS Identity and Access Management API para excluir a função AWSService RoleForCodeStarNotifications vinculada ao serviço. Para saber mais, consulte [Excluir um perfil vinculado ao serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) no *Guia do usuário do IAM*.
## Regiões suportadas para funções AWS CodeStar vinculadas ao serviço de notificações
AWS CodeStar As notificações oferecem suporte ao uso de funções vinculadas ao serviço em todas as AWS regiões em que o serviço está disponível. Para obter mais informações, consulte [AWS Regiões e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html) e [AWS CodeStar Notificações](https://docs.aws.amazon.com/general/latest/gr/codestar_notifications.html).
# Usando funções vinculadas a serviços para Conexões de código da AWS
Conexões de código da AWS usa funções [vinculadas ao serviço AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-linked-role) (IAM). Uma função vinculada ao serviço é um tipo exclusivo de função do IAM vinculada diretamente a. Conexões de código da AWS As funções vinculadas ao serviço são predefinidas Conexões de código da AWS e incluem todas as permissões que o serviço exige para chamar outros AWS serviços em seu nome. Esse perfil é criado na primeira vez que você cria uma conexão. Não é necessário criar a função.
Uma função vinculada ao serviço Conexões de código da AWS facilita a configuração porque você não precisa adicionar permissões manualmente. Conexões de código da AWS define as permissões de suas funções vinculadas ao serviço e, a menos que seja definido de outra forma, só Conexões de código da AWS pode assumir suas funções. As permissões definidas incluem a política de confiança e a política de permissões, que não pode ser anexada a nenhuma outra entidade do IAM.
Para excluir uma função vinculada ao serviço, primeiro é necessário excluir os recursos relacionados. Isso protege seus Conexões de código da AWS recursos porque você não pode remover inadvertidamente a permissão para acessar os recursos.
Para obter informações sobre outros produtos que oferecem suporte a funções vinculadas a serviços, consulte [Serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html).
**nota**
Ações para recursos criados sob o novo prefixo de serviço `codeconnections` estão disponíveis. A criação de um recurso com o novo prefixo de serviço será usada `codeconnections` no ARN do recurso. As ações e os recursos para o prefixo `codestar-connections` de serviço permanecem disponíveis. Ao especificar um recurso na política do IAM, o prefixo do serviço precisa corresponder ao do recurso.
## Permissões de função vinculadas ao serviço para Conexões de código da AWS
Conexões de código da AWS usa a função AWSService RoleForGitSync vinculada ao serviço para usar o Git sync com repositórios conectados baseados no Git.
A função AWSService RoleForGitSync vinculada ao serviço confia nos seguintes serviços para assumir a função:
+ `repository.sync.codeconnections.amazonaws.com`
A política de permissões de função nomeada AWSGit SyncServiceRolePolicy Conexões de código da AWS permite concluir as seguintes ações nos recursos especificados:
+ Ação: concede permissões para que os usuários criem conexões com repositórios externos baseados em Git e usem a sincronização Git com esses repositórios.
Você deve configurar permissões para que uma entidade do IAM (por exemplo, um usuário, grupo ou função) crie, edite ou exclua um perfil vinculado a serviço. Para saber mais, consulte [Permissões de Função Vinculadas ao Serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#service-linked-role-permissions) no *Guia do Usuário do IAM*.
## Criação de uma função vinculada ao serviço para Conexões de código da AWS
Não é necessário criar manualmente um perfil vinculado ao serviço. Você cria a função ao criar um recurso para seu projeto sincronizado com o Git com a API. CreateRepositoryLink
Se excluir esse perfil vinculado ao serviço e precisar criá-lo novamente, será possível usar esse mesmo processo para recriar o perfil em sua conta.
## Editando uma função vinculada ao serviço para Conexões de código da AWS
Depois que criar uma função vinculada ao serviço, você não poderá alterar o nome da função, pois várias entidades podem fazer referência a ela. No entanto, é possível usar o IAM para editar a descrição da função. Para saber mais, consulte [Editar uma função vinculada a serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) no *Guia do usuário do IAM*.
## Excluindo uma função vinculada ao serviço para Conexões de código da AWS
Se você não precisar mais usar um recurso ou serviço que requer uma função vinculada a serviço, é recomendável excluí-la. Dessa forma, você não tem uma entidade não utilizada que não seja monitorada ativamente ou mantida. É necessário limpar os recursos de sua função vinculada ao serviço antes de excluí-la. Isso significa excluir todas as conexões que usam a função de serviço em sua AWS conta.
**nota**
Se o Conexões de código da AWS serviço estiver usando a função quando você tentar excluir os recursos, a exclusão poderá falhar. Se isso acontecer, espere alguns minutos e tente a operação novamente.
**Para excluir Conexões de código da AWS recursos usados pelo AWSService RoleForGitSync**
1. Abra o console do Developer Tools e escolha **Configurações**.
1. Escolha todas as conexões que aparecem na lista e escolha **Excluir**.
1. Repita essas etapas em todas as AWS regiões em que você criou conexões.
**Para **usar o IAM** para excluir a função vinculada ao serviço **
Use o console do IAM ou AWS CLI a AWS Identity and Access Management API para excluir a função AWSService RoleForGitSync vinculada ao serviço. Para saber mais, consulte [Excluir um perfil vinculado ao serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) no *Guia do usuário do IAM*.
## Regiões suportadas para funções vinculadas a Conexões de código da AWS serviços
Conexões de código da AWS suporta o uso de funções vinculadas ao serviço em todas as AWS regiões em que o serviço está disponível. Para obter mais informações, consulte [Regiões e endpoints da AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html).
# AWS políticas gerenciadas para Conexões de código da AWS
Uma política AWS gerenciada é uma política autônoma criada e administrada por AWS. AWS as políticas gerenciadas são projetadas para fornecer permissões para muitos casos de uso comuns, para que você possa começar a atribuir permissões a usuários, grupos e funções.
Lembre-se de que as políticas AWS gerenciadas podem não conceder permissões de privilégio mínimo para seus casos de uso específicos porque elas estão disponíveis para uso de todos os AWS clientes. Recomendamos que você reduza ainda mais as permissões definindo as [ políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) que são específicas para seus casos de uso.
Você não pode alterar as permissões definidas nas políticas AWS gerenciadas. Se AWS atualizar as permissões definidas em uma política AWS gerenciada, a atualização afetará todas as identidades principais (usuários, grupos e funções) às quais a política está anexada. AWS é mais provável que atualize uma política AWS gerenciada quando uma nova AWS service (Serviço da AWS) é lançada ou novas operações de API são disponibilizadas para serviços existentes.
Para saber mais, consulte [AWS Políticas gerenciadas pela ](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Guia do usuário do IAM*.
**nota**
Ações para recursos criados sob o novo prefixo de serviço `codeconnections` estão disponíveis. A criação de um recurso com o novo prefixo de serviço será usada `codeconnections` no ARN do recurso. As ações e os recursos para o prefixo `codestar-connections` de serviço permanecem disponíveis. Ao especificar um recurso na política do IAM, o prefixo do serviço precisa corresponder ao do recurso.
## AWS política gerenciada: AWSGit SyncServiceRolePolicy
Você não pode se vincular AWSGit SyncServiceRolePolicy às suas entidades do IAM. Essa política está vinculada a uma função vinculada ao serviço que permite Conexões de código da AWS realizar ações em seu nome. Para obter mais informações, consulte [Usando funções vinculadas a serviços para Conexões de código da AWS](service-linked-role-connections.md).
Essa política permite que os clientes acessem repositórios baseados em Git para uso com conexões. Os clientes acessarão esses recursos depois de usar a CreateRepositoryLink API.
**Detalhes das permissões**
Esta política inclui as seguintes permissões.
+ `codeconnections`: concede permissões para que os usuários criem conexões com repositórios externos baseados em Git.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessGitRepos",
"Effect": "Allow",
"Action": [
"codestar-connections:UseConnection",
"codeconnections:UseConnection"
],
"Resource": [
"arn:aws:codestar-connections:*:*:connection/*",
"arn:aws:codeconnections:*:*:connection/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "${aws:PrincipalAccount}"
}
}
}
]
}
```
------
## Conexões de código da AWS atualizações nas políticas AWS gerenciadas
Veja detalhes sobre as atualizações das políticas AWS gerenciadas Conexões de código da AWS desde que esse serviço começou a rastrear essas alterações. Para receber alertas automáticos sobre alterações nessa página, assine o feed RSS na página [Histórico do Conexões de código da AWS documento](doc-history.md).
| Alteração | Descrição | Data |
| --- | --- | --- |
| [AWSGitSyncServiceRolePolicy](#security-iam-awsmanpol-AWSGitSyncServiceRolePolicy): política atualizada | O nome do serviço AWS CodeStar Connections foi alterado para Conexões de código da AWS. Atualizou a política para recursos ARNs que contêm os dois prefixos de serviço. | 26 de abril de 2024 |
| [AWSGitSyncServiceRolePolicy](#security-iam-awsmanpol-AWSGitSyncServiceRolePolicy) – Nova política | O AWS CodeStar Connections adicionou a política. Concede permissões para permitir que usuários de conexões usem o Git sync com repositórios conectados baseados no Git. | 26 de novembro de 2023 |
| Conexões de código da AWS começou a rastrear alterações | Conexões de código da AWS começou a rastrear as mudanças em suas políticas AWS gerenciadas. | 26 de novembro de 2023 |
# Validação de conformidade para AWS CodeStar notificações e AWS CodeConnections
Para obter uma lista de AWS serviços no escopo de programas de conformidade específicos, consulte [AWS serviços no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/). Para obter informações gerais, consulte [Programas de conformidade da AWS](https://aws.amazon.com/compliance/programs/).
Você pode baixar relatórios de auditoria de terceiros usando AWS Artifact. Para obter mais informações, consulte Como [baixar relatórios no AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html).
Sua responsabilidade de conformidade ao usar AWS CodeStar as Notificações AWS CodeConnections é determinada pela confidencialidade de seus dados, pelos objetivos de conformidade da sua empresa e pelas leis e regulamentações aplicáveis. AWS fornece os seguintes recursos para ajudar na conformidade:
+ [Guias de início rápido sobre segurança e conformidade](https://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance) — Esses guias de implantação discutem considerações arquitetônicas e fornecem etapas para a implantação de ambientes básicos focados em segurança e conformidade em. AWS
+ [AWS recursos de conformidade](https://aws.amazon.com/compliance/resources/) — essa coleção de pastas de trabalho e guias pode ser aplicada ao seu setor e local.
+ [AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html)— Esse AWS serviço avalia se suas configurações de recursos estão em conformidade com as práticas internas, as diretrizes e os regulamentos do setor.
+ [AWS Security Hub CSPM](https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html)— Esse AWS serviço fornece uma visão abrangente do seu estado de segurança interno, AWS que ajuda você a verificar sua conformidade com os padrões e as melhores práticas do setor de segurança.
# Resiliência em AWS CodeStar notificações e AWS CodeConnections
A infraestrutura AWS global é construída em torno de AWS regiões e zonas de disponibilidade. AWS As regiões fornecem várias zonas de disponibilidade fisicamente separadas e isoladas, conectadas a redes de baixa latência, alta taxa de transferência e alta redundância. Com as zonas de disponibilidade, é possível projetar e operar aplicações e bancos de dados que executam o failover automaticamente entre as zonas de disponibilidade sem interrupção. As zonas de disponibilidade são mais altamente disponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais.
Para obter mais informações sobre AWS regiões e zonas de disponibilidade, consulte [infraestrutura AWS global](https://aws.amazon.com/about-aws/global-infrastructure/).
+ As regras de notificação são específicas do Região da AWS local em que foram criadas. Se você tiver regras de notificação em mais de uma Região da AWS, use o seletor de região para revisar as regras de notificação em cada uma Região da AWS.
+ AWS CodeStar As notificações se baseiam nos tópicos do Amazon Simple Notification Service (Amazon SNS) como alvos das regras de notificação. As informações sobre seus tópicos do Amazon SNS e destinos da regra de notificação podem ser armazenadas em uma região da AWS fora da região em que você configurou a regra de notificação.
# Segurança da infraestrutura em AWS CodeStar notificações e AWS CodeConnections
Como recursos em um serviço gerenciado, AWS CodeStar as Notificações AWS CodeConnections são protegidas pelos procedimentos AWS globais de segurança de rede descritos no whitepaper [Amazon Web Services: Visão geral dos processos de segurança](https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf).
Você usa chamadas de API AWS publicadas para acessar AWS CodeStar as notificações e AWS CodeConnections por meio da rede. Os clientes devem oferecer suporte a Transport Layer Security (TLS) 1.0 ou posterior. Os clientes também devem ter suporte a 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 suporta 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.
## Tráfego entre Conexões de código da AWS recursos em todas as regiões
Se você usar o recurso de conexões para permitir a conexão de seus recursos, você concorda e nos instrui a armazenar e processar as informações associadas a esses recursos de conexão Regiões da AWS fora do Regiões da AWS local em que você está usando o serviço subjacente, exclusivamente em conexão com e com o único propósito de fornecer conexão a esses recursos em regiões diferentes daquela em que o recurso foi criado.
Para obter mais informações, consulte [Recursos globais em AWS CodeConnections](welcome-connections-how-it-works-global.md).
**nota**
Se você usar o recurso de conexões para habilitar a conexão de seus recursos em regiões que não precisam ser habilitadas primeiro, armazenaremos e processaremos as informações conforme detalhado nos tópicos anteriores.
Para conexões estabelecidas em regiões que primeiro devem ser habilitadas, como a região Europa (Milão), armazenaremos e processaremos somente as informações dessa conexão nessa região.