Publicar e instalar um pacote no GitHub Actions

Observação: atualmente, o GitHub Packages está em versão beta no GitHub AE.

Sobre GitHub Packages 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, confira "Aprenda o 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.

Para autenticar nos registros de pacotes em GitHub AE, recomendamos usar oGITHUB_TOKEN que o GitHub AE cria automaticamente para seu repositório quando você habilita o GitHub Actions. Você deve definir as permissões desse token de acesso no arquivo de fluxo de trabalho para permitir acesso de leitura ao escopo contents e acesso de gravação ao escopo packages. Para forks, o GITHUB_TOKEN recebe acesso de leitura no repositório pai. Para obter mais informações, confira "Autenticação automática de token".

Você pode referenciar o GITHUB_TOKEN no arquivo de fluxo de trabalho usando o contexto {{secrets.GITHUB_TOKEN}}. Para obter mais informações, confira "Autenticação automática de token".

Sobre permissões e acesso a pacotes

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 do 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, confira "Autenticação automática de token".

O GitHub Packages permite que você efetue push e pull de pacotes por meio do GITHUB_TOKEN disponível para um fluxo de trabalho do GitHub Actions.

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

As etapas de configuração variam de acordo com o cliente do pacote. Para obter informações gerais sobre como configurar um fluxo de trabalho para GitHub Actions, confira "Usando fluxos 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 Docker e publicá-la em GitHub Packages.

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

YAML

# Esse fluxo de trabalho usa ações que não são certificadas pelo GitHub.
# São fornecidas por terceiros e regidas por
# termos de serviço, política de privacidade e suporte separados
# online.

# O GitHub recomenda fixar ações em um SHA de commit.
# Para obter uma versão mais recente, você precisará atualizar o SHA.
# Você também pode fazer referência a uma marca ou branch, mas a ação pode ser alterada sem aviso.

name: Create and publish a Docker image

on:
  push:
    branches: ['release']

jobs:
  run-npm-build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: npm install and build webpack
        run: |
          npm install
          npm run build
      - uses: actions/upload-artifact@v3
        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@v3
      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v3
        with:
          node-version: ${{ matrix.node-version }}
      - uses: actions/download-artifact@v3
        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@v3
      - name: Log in to GitHub Docker Registry
        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9
        with:
          registry: docker.YOUR-HOSTNAME.com
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Build and push Docker image
        uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc
        with:
          push: true
          tags: |
            docker.YOUR-HOSTNAME.com/${{ github.repository }}/octo-image:${{ github.sha }}

As configurações relevantes são explicadas na seguinte tabela. Para ver detalhes completos sobre cada elemento de um fluxo de trabalho, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".

```yaml on: push: branches: ['release'] ```	Configura o fluxo de trabalho `Create and publish a Docker image` para que ele seja executado sempre que uma alteração é enviada por push ao branch chamado `release`.
`run-npm-build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: npm install and build webpack run: \| npm install npm run build - uses: actions/upload-artifact@v3 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: [12.x, 14.x] steps: - uses: actions/checkout@v3 - name: Use Node.js ${{ matrix.node-version }} uses: actions/setup-node@v3 with: node-version: ${{ matrix.node-version }} - uses: actions/download-artifact@v3 with: name: webpack artifacts path: public - name: npm install, and test run: \| npm install npm test env: CI: true`	Ele usa o `npm test` para testar o código. O comando `needs: run-npm-build` torna esse trabalho dependente do trabalho `run-npm-build`.
```yaml build-and-push-image: runs-on: ubuntu-latest needs: run-npm-test ```	Este trabalho publica o pacote. O comando `needs: run-npm-test` torna esse trabalho dependente do trabalho `run-npm-test`.
```yaml permissions: contents: read packages: write ```	Define as permissões concedidas ao `GITHUB_TOKEN` para as ações nesse trabalho.
```yaml - name: Log in to GitHub Docker Registry uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9 with: registry: docker.YOUR-HOSTNAME.com username: ${{ github.actor }} password: ${{ secrets.GITHUB_TOKEN }} ```	Cria uma etapa chamada `Log in to GitHub Docker Registry`, que faz logon no registro usando a conta e a senha que publicará os pacotes. Uma vez publicados, os pacotes têm escopo definido para a conta definida aqui.
```yaml - name: Build and push Docker image ```	Cria uma etapa chamada `Build and push Docker image`. Essa etapa é executada como parte do trabalho `build-and-push-image`.
```yaml uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc ```	Usa a ação `build-push-action` do Docker para compilar a imagem, com base no `Dockerfile` do repositório. Se a criação for bem-sucedida, ela faz p push da imagem para GitHub Packages.
```yaml with: ```	Envia os parâmetros obrigatórios para a ação `build-push-action`. Estas são definidas nas linhas subsequentes.
```yaml push: true ```	Faz push desta imagem para o registro se for construída com sucesso.
```yaml tags: \| docker.YOUR-HOSTNAME.com/${{ github.repository }}/octo-image:${{ github.sha }} ```	Marca a imagem com o SHA do commit que acionou o fluxo de trabalho.

Este novo fluxo de trabalho será executado automaticamente sempre que você efetuar push de uma alteração em um branch chamado release no repositório. Veja o progresso na guia 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, confira "Visualizar pacotes".

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 Packages. Em seguida, o fluxo de trabalho pode executar testes de CI que exigem as dependências.

A instalação de pacotes hospedados pelo GitHub Packages por meio do GitHub Actions exige uma configuração mínima ou uma autenticação adicional quando você usa o GITHUB_TOKEN.