Publicar e instalar um pacote no GitHub Actions

É possível configurar um fluxo de trabalho no GitHub Actions para publicar ou instalar automaticamente um pacote do GitHub Package Registry.

GitHub Package Registry is available with GitHub Free, GitHub Pro, GitHub Free for organizations, GitHub Team, GitHub Enterprise Cloud, GitHub Enterprise Server, and GitHub AE.


O GitHub Package Registry não está disponível para repositórios privados de contas que utilizam planos antigos por-repositório. Also, accounts using legacy per-repository plans cannot access the Container registry since these accounts are billed by repository. Para obter mais informações, consulte "[produtos de GitHub](/articles/github-s-products)

Sobre GitHub Package Registry com GitHub Actions

O GitHub Actions ajuda você a automatizar seus fluxos de trabalho de desenvolvimento de software no mesmo lugar que você armazena o código e colabora em pull requests e problemas. Você pode escrever tarefas individuais, chamadas de ações e combiná-las para criar um fluxo de trabalho personalizado. Com o GitHub Actions, você pode criar recursos completos de integração contínua (CI, Continuous Integration) e implantação contínua (CD, Continuous Deployment) diretamente no seu repositório. Para obter mais informações, consulte "Sobre GitHub Actions".

Você pode estender os recursos de CI e CD do seu repositório publicando ou instalando pacotes como parte do seu fluxo de trabalho.

Efetuar a autenticação no Container registry

Os PATs podem conceder amplo acesso à sua conta. You should select only the necessary read:packages, write:packages, or delete:packages scope when creating a PAT to authenticate to the Container registry.

To authenticate to the Container registry within a GitHub Actions workflow, use the GITHUB_TOKEN for the best security and experience.

For guidance on updating your workflows that authenticate to ghcr.io with a personal access token, see "Upgrading a workflow that accesses ghcr.io."

Se você desejar usar o Container registry em ações durante a versão beta, siga nossas práticas de segurança recomendadas para o uso do PAT emFortalecimento da segurança para o GitHub Actions".

Para um exemplo de autenticação, consulte "Efetuar a autenticação com o Container registry".

Efetuar a autenticação nos registros do pacote em GitHub

Se você deseja que o fluxo de trabalho efetue a autenticação em GitHub Package Registry para acessar um registro de pacotes diferentes do Container registry em GitHub, recomendamos usar o GITHUB_TOKEN que GitHub cria automaticamente para o seu repositório quando você habilita GitHub Actions em vez de um token de acesso pessoal para autenticação. Você deve definir as permissões para este token de acesso no arquivo de fluxo de trabalho para conceder acesso de leitura do escopo do conteúdo e acesso de gravação para o escopo dos pacotes. Para bifurcações, o GITHUB_TOKEN recebe acesso de leitura para o repositório principal. Para obter mais informações, consulte "Autenticação com o GITHUB_TOKEN".

Você pode fazer referência ao GITHUB_TOKEN no seu arquivo de fluxo de trabalho usando o contexto {{secrets.GITHUB_TOKEN}}. Para obter mais informações, consulte "Permissões para o GITHUB_TOKEN".

Sobre permissões e acesso de pacote para pacotes pertencentes ao repositório

Observação: Os pacotes que possuem repositórios incluem RubyGems, npm, Apache Maven, NuGet, Gradle e Docker que usam o namespace docker.pkg.github.com.

Quando você habilita o GitHub Actions, o GitHub instala um aplicativo GitHub no repositório. O segredo GITHUB_TOKEN é um token de acesso de instalação do aplicativo GitHub. Você pode usar o token de acesso de instalação para efetuar a autenticação em nome do aplicativo GitHub instalado no seu repositório. As permissões do token são restritas ao repositório do fluxo de trabalho. Para obter mais informações, consulte "Permissões para o GITHUB_TOKEN".

GitHub Package Registry permite que você faça push e pull de pacotes por meio do GITHUB_TOKEN disponível para um fluxo de trabalho de GitHub Actions.

Sobre permissões e acesso de pacote para Container registry

O Container registry (ghcr.io) permite aos usuários criar e administrar contêineres como recursos independentes no nível da organização. Os contêineres podem pertencer a uma conta de usuário ou organização e você pode personalizar o acesso a cada um dos seus contêineres separadamente das permissões de repositório.

Todos os workflows que acessam o Container registry devem usar o GITHUB_TOKEN em vez de um token de acesso pessoal. Para obter mais informações sobre as melhores práticas de segurança, consulte "Enrijecimento de segurança para o GitHub Actions".

Configurações padrão de permissões e acesso para contêineres modificados por meio de fluxos de trabalho

Ao criar, instalar, modificar ou excluir um contêiner por meio de um fluxo de trabalho, existem algumas configurações padrão de permissão e acesso para garantir que os administradores tenham acesso ao fluxo de trabalho. Você também pode ajustar estas configurações de acesso.

Por exemplo, por padrão, se um fluxo de trabalho cria um contêiner usando o GITHUB_TOKEN:

  • O contêiner herdará o modelo de visibilidade e permissões do repositório onde o fluxo de trabalho é executado.
  • Os administradores do repositório onde o fluxo de trabalho é executado tornam-se os administradores do contêiner depois que o contêiner é criado.

Estes são outros exemplos de como as permissões padrão funcionam para fluxos de trabalho que gerenciam pacotes.

Tarefa de fluxo de trabalho de GitHub ActionsAcesso e permissões padrão
Faça o download de um contêiner existente- Se o contêiner for público, qualquer fluxo de trabalho em execução em qualquer repositório poderá fazer o download do container.
- Se o contêiner for interno, todos os fluxos de trabalho em execução em qualquer repositório pertencente à conta corporativa poderão fazer o download do contêiner. Para organizações pertencentes a empresas, você poderá ler qualquer repositório na empresa
- Se o contêiner for privado, somente fluxos de trabalho executados em repositórios que recebem permissões de leitura nesse contêiner podem fazer o download do container.
Faça o upload de uma nova versão para um contêiner existente- Se o contêiner for privado, interno ou público, somente fluxos de trabalho executados em repositórios que recebem permissões de gravação nesse contêiner podem fazer o upload de novas versões para o container.
Excluir um contêiner ou versões de um contêiner- Se o recipiente for privado, interno ou público, somente fluxos de trabalho executados em repositórios que recebem permissão de exclusão pode excluir versões existentes do container.

Você também pode ajustar o acesso a contêineres de uma forma mais granular ou ajustar alguns dos comportamentos padrão de permissões. Para obter mais informações, consulte "Configurar o controle de acesso e visibilidade de um pacote".

Publicar um pacote usando uma ação

Você pode usar GitHub Actions para publicar automaticamente pacotes como parte do fluxo de integração contínua (CI). Esta abordagem da implantação contínua (CD) permite que você automatize a criação de novas versões do pacote, se o código atender aos seus padrões de qualidade. Por exemplo, você pode criar um fluxo de trabalho que executa testes CI toda vez que um desenvolvedor faz push do código para um branch específico. Se os testes passarem, o fluxo de trabalho poderá publicar uma nova versão do pacote em GitHub Package Registry.

As etapas de configuração variam de acordo com o cliente do pacote. Para obter informações gerais sobre a configuração de um fluxo de trabalho para GitHub Actions, consulte "Configurar um fluxo de trabalho."

O exemplo a seguir demonstra como você pode usar GitHub Actions para criar e testar seu aplicativo e, em seguida, criar automaticamente uma imagem do Docker e publicá-la em GitHub Package Registry:

  • Crie um novo arquivo de fluxo de trabalho no repositório (como .github/workflows/deploy-image.yml) e adicione o YAML a seguir:

    YAML
    name: Create and publish a package
    on:
      push:
        branches: ['release']
    jobs:
      run-npm-build:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v2
          - name: npm install and build webpack
            run: |
              npm install
              npm run build
          - uses: actions/upload-artifact@main
            with:
              name: webpack artifacts
              path: public/
    
      run-npm-test:
        runs-on: ubuntu-latest
        needs: run-npm-build
        strategy:
          matrix:
            os: [ubuntu-latest]
            node-version: [12.x, 14.x]
        steps: 
          - uses: actions/checkout@v2
          - name: Use Node.js ${{ matrix.node-version }}
            uses: actions/setup-node@v1
            with:
              node-version: ${{ matrix.node-version }}
          - uses: actions/download-artifact@main
            with:
              name: webpack artifacts
              path: public
          - name: npm install, and test
            run: |
              npm install
              npm test
            env:
              CI: true
    
      build-and-push-image:
        runs-on: ubuntu-latest
        needs: run-npm-test 
        permissions: 
          contents: read
          packages: write 
        steps:
          - name: Checkout
            uses: actions/checkout@v2
          - name: Log in to GitHub Docker Registry
            uses: docker/login-action@v1
            with:
              registry: docker.pkg.github.com
              username: ${{ github.actor }}
              password: ${{ secrets.GITHUB_TOKEN }}
          - name: Build container image
            uses: docker/build-push-action@v2
            with:
              push: true
              tags: |
                docker.pkg.github.com/${{ github.repository }}/octo-image:${{ github.sha }}
                docker.pkg.github.com/${{ github.repository }}/octo-image:${{ github.ref }}

    As configurações relevantes são explicadas na seguinte tabela:

    on:
      push:
        branches: ['release']
    Configura o fluxo de trabalho Criar e publicar um pacote para ser executado toda vez que uma alteração é enviada para o branch denominado versão.
    run-npm-build:
      runs-on: ubuntu-latest
      steps:
        - uses: actions/checkout@v2
        - name: npm install and build webpack
          run: |
            npm install
            npm run build
        - uses: actions/upload-artifact@main
          with:
            name: webpack artifacts
            path: public/
    Este trabalho instala o NPM e o usa para criar o aplicativo.
    run-npm-test:
      runs-on: ubuntu-latest
      needs: run-npm-build
      strategy:
        matrix:
          os: [ubuntu-latest]
          node-version: [14.x]
      steps:
        - uses: actions/checkout@v2
        - name: Use Node.js ${{ matrix.node-version }}
          uses: actions/setup-node@v1
          with:
            node-version: ${{ matrix.node-version }}
        - uses: actions/download-artifact@main
          with:
            name: webpack artifacts
            path: public
        - name: npm install, and test
          run: |
            npm install
            npm test
          env:
            CI: true
    Este trabalho usa teste do npm para testar o código. O comando needs: run-npm-build torna esse trabalho dependente do trabalho run-npm-build.
      build-and-push-image:
        runs-on: ubuntu-latest
        needs: run-npm-test
    Este trabalho publica o pacote. O comando needs: run-npm-test torna essa tarefa dependente do trabalho run-npm-test.
    permissions: 
      contents: read
      packages: write 
    Define as permissões concedidas ao GITHUB_TOKEN para as ações deste trabalho.
    - name: Log in to GitHub Docker Registry
      uses: docker/login-action@v1
      with:
        registry: docker.pkg.github.com
        username: ${{ github.actor }}
        password: ${{ secrets.GITHUB_TOKEN }}
    Cria uma nova etapa denominada Iniciar sessão no registro do GitHub Docker, que faz login no registro usando a conta e a senha que publicará os pacotes. Uma vez publicados, os pacotes pertencem à conta definida aqui.
    - name: Build container image
    Cria uma nova etapa denominada Build container image. Esta etapa é executada como parte do trabalho build-and-push-image.
    uses: docker/build-push-action@v2
    Usa a ação build-push-action do Docker para criar a imagem com base no arquivo Docker do seu repositório. Se a criação for bem-sucedida, ela faz p push da imagem para GitHub Package Registry.
    with:
    Envia os parâmetros necessários para a ação build-push-action. Isto é definido nas linhas subsequentes.
    push: true
    Faça push desta imagem para o registro se for construída com sucesso.
    tags: |
    docker.pkg.github.com/${{ github.repository }}/octo-image:${{ github.sha }}
    docker.pkg.github.com/${{ github.repository }}/octo-image:${{ github.ref }}
    Marca o pacote publicado com o ref do git (por exemplo, o nome do branch usado para criar o pacote), bem como o SHA do commit.
    • Este novo fluxo de trabalho será executado automaticamente toda vez que você fizer uma alteração em uma versão nomeada do branch no repositório. Você pode visualizar o progresso na aba Ações.
    • Alguns minutos após a conclusão do fluxo de trabalho, o novo pacote ficará visível no seu repositório. Para encontrar seus pacotes disponíveis, consulte "Visualizar os pacotes de um repositório".

    Instalar um pacote usando uma ação

    Você pode instalar pacotes como parte de seu fluxo de CI usando o GitHub Actions. Por exemplo, você poderia configurar um fluxo de trabalho para que sempre que um desenvolvedor fizesse push do código para um pull request, o fluxo de trabalho resolveria as dependências, fazendo o download e instalando pacotes hospedados pelo GitHub Package Registry. Em seguida, o fluxo de trabalho pode executar testes de CI que exigem as dependências.

    A instalação de pacotes hospedados pelo GitHub Package Registry através GitHub Actions exige uma configuração mínima ou uma autenticação adicional quando você usa o GITHUB_TOKEN. A transferência de dados também é gratuita quando uma ação instala um pacote. Para obter mais informações, consulte "Sobre a cobrança do GitHub Package Registry".

    As etapas de configuração variam de acordo com o cliente do pacote. Para obter informações gerais sobre a configuração de um fluxo de trabalho para GitHub Actions, consulte "Configurar um fluxo de trabalho."

    Atualizando um fluxo de trabalho que acessa ghcr.io

    O uso do GITHUB_TOKEN em vez de um PAT, que inclui o escopo do repositório aumenta a segurança do repositório, pois você não precisa usar um PAT de longa duração que oferece acesso desnecessário ao repositório em que o seu fluxo de trabalho é executado. Para obter mais informações sobre as melhores práticas de segurança, consulte "Enrijecimento de segurança para o GitHub Actions".

    1. Acesse a página inicial do seu pacote.

    2. Na barra lateral esquerda, clique em Acesso às ações. Opção "Ações de acesso" no menu à esquerda

    3. Para garantir que seu pacote de contêiner tenha acesso ao seu fluxo de trabalho, você deve adicionar o repositório em que o fluxo de trabalho é armazenado no contêiner. Clique Adicionar repositório e pesquise o repositório que deseja adicionar. Botão "Adicionar repositório"

      Observação: Adicionar um repositório ao seu contêiner por meio da opção de menu Acesso às ações é diferente de conectar seu contêiner a um repositório. Para obter mais informações, consulte "Garantir o acesso ao fluxo de trabalho para o seu pacote" "Conectar um repositório a um pacote".

    4. Opcionalmente, usando o menu suspenso "função", selecione o nível de acesso padrão que você gostaria que o repositório tivesse na imagem do seu contêiner. Níveis de acesso permitidos para repositórios

    5. Abra o arquivo do seu fluxo de trabalho. Na linha em que você efetua o login em ghcr.io, substitua o seu PAT por ${{ secrets.GITHUB_TOKEN }}.

    Por exemplo, este fluxo de trabalho publica um contêiner do Docker usando ${{ secrets.GITHUB_TOKEN }} para efetuar a autenticação.

    YAML
    name: Demo Push
    
    on:   
      push:
        # Publish `master` as Docker `latest` image.
        branches:
          - master
          - seed
    
        # Publish `v1.2.3` tags as releases.
        tags:
          - v*
    
      # Run tests for any PRs.
      pull_request:
    
    env:
      IMAGE_NAME: ghtoken_product_demo
    
    jobs:
      # Push image to GitHub Packages.
      # See also https://docs.docker.com/docker-hub/builds/
      push:
        runs-on: ubuntu-latest
        permissions:
          packages: write
          contents: read
    
        steps:
          - uses: actions/checkout@v2
    
          - name: Build image
            run: docker build . --file Dockerfile --tag $IMAGE_NAME --label "runnumber=${GITHUB_RUN_ID}"
    
          - name: Log into registry
            # This is where you will update the PAT to GITHUB_TOKEN
            run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
    
          - name: Push image
            run: |
              IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME
    
              # Change all uppercase to lowercase
              IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]')
              # Strip git ref prefix from version
              VERSION=$(echo "${{ github.ref }}" | sed -e 's,.*/\(.*\),\1,')
              # Strip "v" prefix from tag name
              [[ "${{ github.ref }}" == "refs/tags/"* ]] && VERSION=$(echo $VERSION | sed -e 's/^v//')
              # Use Docker `latest` tag convention
              [ "$VERSION" == "master" ] && VERSION=latest
              echo IMAGE_ID=$IMAGE_ID
              echo VERSION=$VERSION
              docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
              docker push $IMAGE_ID:$VERSION

Esse documento ajudou você?Política de Privacidade

Ajude-nos a tornar esses documentos ótimos!

Todos os documentos do GitHub são de código aberto. Você percebeu que algo que está errado ou não está claro? Envie um pull request.

Faça uma contribuição

Ou, aprenda como contribuir.