Exemplos de política gerenciada pelo cliente - AWS CodeCommit
Exemplos de políticas de identidade gerenciadas pelo clienteExemplos de políticas de integração gerenciadas pelo cliente

AWS CodeCommit não está mais disponível para novos clientes. Os clientes atuais do AWS CodeCommit podem continuar usando o serviço normalmente. Saiba mais

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

Exemplos de política gerenciada pelo cliente

Você pode criar suas próprias políticas personalizadas do IAM para permitir permissões para CodeCommit ações e recursos. Você pode anexar essas políticas personalizadas a usuários ou grupos do IAM que exijam essas permissões. Você também pode criar suas próprias políticas personalizadas de IAM para integração CodeCommit entre outros AWS serviços.

Exemplos de políticas de identidade gerenciadas pelo cliente

O exemplo a seguir de políticas do IAM concede permissões para várias CodeCommit ações. Use-os para limitar o CodeCommit acesso de seus usuários e funções do IAM. Essas políticas controlam a capacidade de realizar ações com o CodeCommit console, a API, AWS os SDKs ou o. AWS CLI

nota

Todos os exemplos usam a região do Oeste dos EUA (Oregon) (us-west-2) e contêm IDs de contas fictícias.

Exemplos

Exemplo 1: Permitir que um usuário realize CodeCommit operações em uma única Região da AWS

A política de permissões a seguir usa um caractere curinga ("codecommit:*") para permitir que os usuários realizem todas as CodeCommit ações na região us-east-2 e não em outra. Regiões da AWS

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "codecommit:*",
            "Resource": "arn:aws:codecommit:us-east-2:111111111111:*",
            "Condition": {
                "StringEquals": {
                    "aws:RequestedRegion": "us-east-2"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": "codecommit:ListRepositories",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "aws:RequestedRegion": "us-east-2"
                }
            }
        }
    ]
}

Exemplo 2: permitir que um usuário use o Git para um único repositório

Em CodeCommit, as permissões da política GitPull do IAM se aplicam a qualquer comando do cliente Git do qual os dados são recuperados CodeCommit, incluindo git fetchgit clone, e assim por diante. Da mesma forma, as permissões da política GitPush do IAM se aplicam a qualquer comando do cliente Git para o qual os dados são enviados. CodeCommit Por exemplo, se a permissão da política GitPush do IAM estiver definida como Allow, um usuário poderá enviar via push a exclusão de uma ramificação usando o protocolo Git. Esse envio via push não é afetado por qualquer permissão aplicada à operação DeleteBranch para esse usuário do IAM. A DeleteBranch permissão se aplica às ações realizadas com o console, o AWS CLI, os SDKs e a API, mas não com o protocolo Git.

O exemplo a seguir permite que o usuário especificado extraia e envie para o CodeCommit repositório chamadoMyDemoRepo:

{
  "Version": "2012-10-17",
  "Statement" : [
    {
      "Effect" : "Allow",
      "Action" : [
        "codecommit:GitPull",
        "codecommit:GitPush"
      ],
      "Resource" : "arn:aws:codecommit:us-east-2:111111111111:MyDemoRepo"
    }
  ]
}

Exemplo 3: permitir que um usuário conectado a partir de um intervalo de endereços IP especificado acesse um repositório

Você pode criar uma política que só permita que os usuários se conectem a um CodeCommit repositório se o endereço IP estiver dentro de um determinado intervalo de endereços IP. Existem duas abordagens igualmente válidas para isso. Você pode criar uma Deny política que CodeCommit proíba operações se o endereço IP do usuário não estiver dentro de um bloco específico ou criar uma Allow política que permita CodeCommit operações se o endereço IP do usuário estiver dentro de um bloco específico.

Você pode criar uma política Deny que nega o acesso a todos os usuários que não estão dentro de um determinado intervalo de IPs. Por exemplo, você pode anexar a política AWSCodeCommitPowerUser gerenciada e uma política gerenciada pelo cliente a todos os usuários que precisam de acesso ao seu repositório. O exemplo de política a seguir nega todas as CodeCommit permissões aos usuários cujos endereços IP não estejam dentro do bloco de endereços IP especificado de 203.0.113.0/16:

{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Effect": "Deny",
         "Action": [
            "codecommit:*"
         ],
         "Resource": "*",
         "Condition": {
            "NotIpAddress": {
               "aws:SourceIp": [
                  "203.0.113.0/16"
               ]
            }
         }
      }
   ]
}

O exemplo de política a seguir permite que o usuário especificado acesse um CodeCommit repositório nomeado MyDemoRepo com as permissões equivalentes da política AWSCodeCommitPowerUser gerenciada somente se o endereço IP estiver dentro do bloco de endereços especificado de 203.0.113.0/16:

{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Effect": "Allow",
         "Action": [
            "codecommit:BatchGetRepositories",
            "codecommit:CreateBranch",
            "codecommit:CreateRepository",
            "codecommit:Get*",
            "codecommit:GitPull",
            "codecommit:GitPush",
            "codecommit:List*",
            "codecommit:Put*",
            "codecommit:Post*",
            "codecommit:Merge*",
            "codecommit:TagResource",
            "codecommit:Test*",
            "codecommit:UntagResource",
            "codecommit:Update*"
         ],
         "Resource": "arn:aws:codecommit:us-east-2:111111111111:MyDemoRepo",
         "Condition": {
            "IpAddress": {
               "aws:SourceIp": [
                  "203.0.113.0/16"
               ]
            }
         }
      }
   ]
}

Exemplo 4: negar ou permitir ações em ramificações

Você pode criar uma política que nega aos usuários permissões para as ações que você especificar em uma ou mais ramificações. Como alternativa, você pode criar uma política que permita ações em uma ou mais ramificações que, de outra forma, elas não teriam em outras ramificações de um repositório. Você pode usar essas políticas com as políticas gerenciadas adequadas (predefinidas). Para ter mais informações, consulte Limite os envios e fusões às ramificações em AWS CodeCommit.

Por exemplo, você pode criar uma Deny política que negue aos usuários a capacidade de fazer alterações em uma ramificação chamada main, incluindo a exclusão dessa ramificação, em um repositório chamado. MyDemoRepo Você pode usar essa política com a política AWSCodeCommitPowerUsergerenciada. Os usuários com essas duas políticas aplicadas poderiam criar e excluir ramificações, criar pull requests e todas as outras ações conforme permitido AWSCodeCommitPowerUser, mas não conseguiriam enviar alterações para a ramificação chamada main, adicionar ou editar um arquivo na ramificação principal no CodeCommit console ou mesclar ramificações ou uma pull request na ramificação principal. Como Deny é aplicado ao GitPush, você deve incluir uma instrução Null à política para permitir que as chamadas GitPush iniciais sejam analisadas para validação quando os usuários fizerem envios por push de seus repositórios locais.

dica

Se desejar criar uma política que se aplica a todas as ramificações chamadas master em todos os repositórios da sua conta da Amazon Web Services, em Resource, especifique um asterisco ( * ) em vez de um ARN de repositório.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": [
                "codecommit:GitPush",
                "codecommit:DeleteBranch",
                "codecommit:PutFile",
                "codecommit:Merge*"
            ],
            "Resource": "arn:aws:codecommit:us-east-2:111111111111:MyDemoRepo",
            "Condition": {
                "StringEqualsIfExists": {
                    "codecommit:References": [
                        "refs/heads/main"   
                    ]
                },
                "Null": {
                    "codecommit:References": "false"
                }
            }
        }
    ]
}

O exemplo de política a seguir permite ao usuário fazer alterações em uma ramificação chamada master em todos os repositórios de uma conta da Amazon Web Services. Ele não permitirá alterações em nenhuma outra ramificação. Você pode usar essa política com a política AWSCodeCommitReadOnly gerenciada para permitir envios automatizados para o repositório na ramificação principal. Como o efeito éAllow, esse exemplo de política não funcionaria com políticas gerenciadas, como AWSCodeCommitPowerUser.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "codecommit:GitPush",
                "codecommit:Merge*"
            ],
            "Resource": "*",
            "Condition": {
                "StringEqualsIfExists": {
                    "codecommit:References": [
                        "refs/heads/main"
                    ]
                }
            }
        }
    ]
}

Exemplo 5: negar ou permitir ações em repositórios com tags

Você pode criar uma política que permita ou negue ações em repositórios com base nas AWS tags associadas a esses repositórios e, em seguida, aplicar essas políticas aos grupos do IAM que você configura para gerenciar usuários do IAM. Por exemplo, você pode criar uma política que negue todas as CodeCommit ações em qualquer repositório com a AWS tag Status da chave e o valor da chave Secret e, em seguida, aplicar essa política ao grupo do IAM que você criou para desenvolvedores gerais (desenvolvedores). Em seguida, você precisa garantir que os desenvolvedores que trabalham nesses repositórios marcados não sejam membros desse grupo geral de desenvolvedores, mas pertençam a um grupo diferente do IAM que não tenha a política restritiva aplicada () SecretDevelopers.

O exemplo a seguir nega todas as CodeCommit ações em repositórios marcados com o status da chave e o valor da chave Secret:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Deny",
      "Action": [
        "codecommit:Associate*",
        "codecommit:Batch*",
        "codecommit:CancelUploadArchive",
        "codecommit:CreateBranch",
        "codecommit:CreateCommit",
        "codecommit:CreatePullRequest*",
        "codecommit:CreateRepository",
        "codecommit:CreateUnreferencedMergeCommit",
        "codecommit:DeleteBranch",
        "codecommit:DeleteCommentContent",
        "codecommit:DeleteFile",
        "codecommit:DeletePullRequest*",
        "codecommit:DeleteRepository",
        "codecommit:Describe*",
        "codecommit:DisassociateApprovalRuleTemplateFromRepository",
        "codecommit:EvaluatePullRequestApprovalRules",
        "codecommit:GetBlob",
        "codecommit:GetBranch",
        "codecommit:GetComment*",
        "codecommit:GetCommit",
        "codecommit:GetDifferences*",
        "codecommit:GetFile",
        "codecommit:GetFolder",
        "codecommit:GetMerge*",
        "codecommit:GetObjectIdentifier",
        "codecommit:GetPullRequest*",
        "codecommit:GetReferences",
        "codecommit:GetRepository*",
        "codecommit:GetTree",
        "codecommit:GetUploadArchiveStatus",
        "codecommit:Git*",
        "codecommit:ListAssociatedApprovalRuleTemplatesForRepository",
        "codecommit:ListBranches",
        "codecommit:ListPullRequests",
        "codecommit:ListTagsForResource",
        "codecommit:Merge*",
        "codecommit:OverridePullRequestApprovalRules",
        "codecommit:Post*",
        "codecommit:Put*",
        "codecommit:TagResource",
        "codecommit:TestRepositoryTriggers",
        "codecommit:UntagResource",
        "codecommit:UpdateComment",
        "codecommit:UpdateDefaultBranch",
        "codecommit:UpdatePullRequest*",
        "codecommit:UpdateRepository*",
        "codecommit:UploadArchive"
      ],
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "aws:ResourceTag/Status": "Secret"
        }
      }
    }
  ]
}

Você pode refinar ainda mais essa estratégia, fornecendo repositórios específicos, em vez de todos os repositórios, como recursos. Você também pode criar políticas que permitam CodeCommit ações em todos os repositórios que não estejam marcados com tags específicas. Por exemplo, a política a seguir permite o equivalente a AWSCodeCommitPowerUserpermissões para CodeCommit ações, exceto que ela só permite CodeCommit ações em repositórios não marcados com as tags especificadas:

nota

Este exemplo de política inclui somente ações para CodeCommit. Ela não inclui ações para outros AWS serviços incluídos na política AWSCodeCommitPowerUsergerenciada. Para obter mais informações, consulte AWS política gerenciada: AWSCodeCommitPowerUser.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "codecommit:Associate*",
        "codecommit:Batch*",
        "codecommit:CancelUploadArchive",
        "codecommit:CreateBranch",
        "codecommit:CreateCommit",
        "codecommit:CreatePullRequest*",
        "codecommit:CreateRepository",
        "codecommit:CreateUnreferencedMergeCommit",
        "codecommit:DeleteBranch",
        "codecommit:DeleteCommentContent",
        "codecommit:DeleteFile",
        "codecommit:DeletePullRequest*",
        "codecommit:Describe*",
        "codecommit:DisassociateApprovalRuleTemplateFromRepository",
        "codecommit:EvaluatePullRequestApprovalRules",
        "codecommit:GetBlob",
        "codecommit:GetBranch",
        "codecommit:GetComment*",
        "codecommit:GetCommit",
        "codecommit:GetDifferences*",
        "codecommit:GetFile",
        "codecommit:GetFolder",
        "codecommit:GetMerge*",
        "codecommit:GetObjectIdentifier",
        "codecommit:GetPullRequest*",
        "codecommit:GetReferences",
        "codecommit:GetRepository*",
        "codecommit:GetTree",
        "codecommit:GetUploadArchiveStatus",
        "codecommit:Git*",
        "codecommit:ListAssociatedApprovalRuleTemplatesForRepository",
        "codecommit:ListBranches",
        "codecommit:ListPullRequests",
        "codecommit:ListTagsForResource",
        "codecommit:Merge*",
        "codecommit:OverridePullRequestApprovalRules",
        "codecommit:Post*",
        "codecommit:Put*",
        "codecommit:TagResource",
        "codecommit:TestRepositoryTriggers",
        "codecommit:UntagResource",
        "codecommit:UpdateComment",
        "codecommit:UpdateDefaultBranch",
        "codecommit:UpdatePullRequest*",
        "codecommit:UpdateRepository*",
        "codecommit:UploadArchive"
      ],
      "Resource": "*",
      "Condition": {
        "StringNotEquals": {
          "aws:ResourceTag/Status": "Secret",
          "aws:ResourceTag/Team": "Saanvi"
        }
      }
    },
    {
      "Effect": "Allow",
      "Action": [
        "codecommit:CreateApprovalRuleTemplate",
        "codecommit:GetApprovalRuleTemplate",
        "codecommit:ListApprovalRuleTemplates",
        "codecommit:ListRepositories",
        "codecommit:ListRepositoriesForApprovalRuleTemplate",
        "codecommit:UpdateApprovalRuleTemplateContent",
        "codecommit:UpdateApprovalRuleTemplateDescription",
        "codecommit:UpdateApprovalRuleTemplateName"
      ],
      "Resource": "*"
    }
  ]
}

Exemplos de políticas de integração gerenciadas pelo cliente

Esta seção fornece exemplos de políticas de usuário gerenciadas pelo cliente que concedem permissões para integrações entre outros CodeCommit serviços. AWS Para exemplos específicos de políticas que permitem acesso entre contas a um CodeCommit repositório, consulte. Configurar o acesso entre contas a um AWS CodeCommit repositório usando funções

nota

Todos os exemplos usam a região Oeste dos EUA (Oregon) (us-west-2) quando necessário e contêm IDs Região da AWS de conta fictícios.

Exemplos

Exemplo 1: criar uma política que habilita o acesso entre contas para um tópico do Amazon SNS

Você pode configurar um CodeCommit repositório para que envios de código ou outros eventos acionem ações, como enviar uma notificação do Amazon Simple Notification Service (Amazon SNS). Se você criar o tópico do Amazon SNS com a mesma conta usada para criar o CodeCommit repositório, não precisará configurar políticas ou permissões adicionais do IAM. Você pode criar um tópico e, em seguida, criar o gatilho para o repositório. Para ter mais informações, consulte Crie um gatilho para um SNS tópico da Amazon.

No entanto, se você quiser configurar seu gatilho para usar um tópico do Amazon SNS em outra conta da Amazon Web Services, você deve primeiro configurar esse tópico com uma política que permita CodeCommit publicar nesse tópico. Nessa outra conta, abra o console do Amazon SNS, escolha o tópico da lista e, para Outras ações de tópicos, escolha Editar política de tópico. Na guia Avançado, modifique a política do tópico para CodeCommit permitir a publicação nesse tópico. Por exemplo, se a política fosse padrão, você a modificaria da seguinte maneira: alterando os itens no texto vermelho em itálico para corresponder aos valores do repositório, do tópico do Amazon SNS e da conta:

{
  "Version": "2008-10-17",
  "Id": "__default_policy_ID",
  "Statement": [
    {
      "Sid": "__default_statement_ID",
      "Effect": "Allow",
      "Principal": {
        "AWS": "*"
      },
      "Action": [
        "sns:Subscribe",
        "sns:ListSubscriptionsByTopic",
        "sns:DeleteTopic",
        "sns:GetTopicAttributes",
        "sns:Publish",
        "sns:RemovePermission",
        "sns:AddPermission",        "sns:SetTopicAttributes"
      ],
      "Resource": "arn:aws:sns:us-east-2:111111111111:NotMySNSTopic",
      "Condition": {
        "StringEquals": {
          "AWS:SourceOwner": "111111111111"
        }
      }
     },
     {
      "Sid": "CodeCommit-Policy_ID",
      "Effect": "Allow",
      "Principal": {
        "Service": "codecommit.amazonaws.com"
      },
      "Action": "sns:Publish",
      "Resource": "arn:aws:sns:us-east-2:111111111111:NotMySNSTopic",
      "Condition": {
        "StringEquals": {
          "AWS:SourceArn": "arn:aws:codecommit:us-east-2:111111111111:MyDemoRepo",
          "AWS:SourceAccount": "111111111111"
        }
      }
    }
  ]
}

Exemplo 2: Crie uma política de tópicos do Amazon Simple Notification Service (Amazon SNS) para permitir que a CloudWatch Amazon Events CodeCommit publique eventos no tópico

Você pode configurar CloudWatch eventos para publicar em um tópico do Amazon SNS quando ocorrerem eventos, incluindo CodeCommit eventos. Para fazer isso, você deve garantir que a CloudWatch Events tenha permissão para publicar eventos em seu tópico do Amazon SNS criando uma política para o tópico ou modificando uma política existente para o tópico semelhante à seguinte:

{
  "Version": "2008-10-17",
  "Id": "__default_policy_ID",
  "Statement": [
    {
      "Sid": "__default_statement_ID",
      "Effect": "Allow",
      "Principal": {
        "AWS": "*"
      },
      "Action": "sns:Publish",
      "Resource": "arn:aws:sns:us-east-2:123456789012:MyTopic",
      "Condition": {
        "StringEquals": {
          "AWS:SourceOwner": "123456789012"
        }
      }
    },
    {
      "Sid": "Allow_Publish_Events",
      "Effect": "Allow",
      "Principal": {
        "Service": "events.amazonaws.com"
      },
      "Action": "sns:Publish",
      "Resource": "arn:aws:sns:us-east-2:123456789012:MyTopic"
    }
  ]
}

Para obter mais informações sobre CloudWatch eventos CodeCommit e eventos, consulte Exemplos de CloudWatch eventos de serviços suportados. Para obter mais informações sobre o IAM e a linguagem de políticas, consulte Gramática da linguagem de política JSON do IAM.

Exemplo 3: criar uma política para AWS Lambda integração com um CodeCommit gatilho

Você pode configurar um CodeCommit repositório para que envios de código ou outros eventos acionem ações, como invocar uma função no. AWS Lambda Para ter mais informações, consulte Criar um gatilho para uma função do Lambda. Essas informações são específicas para acionadores e não CloudWatch para eventos.

Se você quiser que o acionador execute uma função do Lambda diretamente (em vez de usar um tópico do Amazon SNS para invocar a função do Lambda), e não configurar o gatilho no console do Lambda, inclua uma declaração semelhante à seguinte na política baseada em recursos da função:

{
  "Statement":{
     "StatementId":"Id-1",
     "Action":"lambda:InvokeFunction",
     "Principal":"codecommit.amazonaws.com",
     "SourceArn":"arn:aws:codecommit:us-east-2:111111111111:MyDemoRepo",
     "SourceAccount":"111111111111"
  }
}

Ao configurar manualmente um CodeCommit gatilho que invoca uma função Lambda, você também deve usar o AddPermissioncomando Lambda para conceder permissão para invocar a função. CodeCommit Para ver um exemplo, consulte a seção Para permitir CodeCommit a execução de uma função Lambda de Criar um gatilho para uma função do Lambda existente.

Para obter mais informações sobre políticas de recursos para funções Lambda, consulte AddPermissionThe Pull/Push Event Models no Developer Guide.AWS Lambda