Observação: no momento, não há suporte para os executores hospedados no GitHub no GitHub Enterprise Server. Você pode ver mais informações sobre o suporte futuro planejado no GitHub public roadmap.
Introdução
Este guia mostra como criar um fluxo de trabalho de integração contínua (CI) que cria e testa o código Node.js. Se o seu teste de CI for aprovado, é possível que você deseje publicar seu código ou um pacote.
Pré-requisitos
Recomendamos que você tenha um entendimento básico do Node.js, YAML, das opções de configuração do fluxo de trabalho e de como criar um arquivo do fluxo de trabalho. Para obter mais informações, consulte:
Usar executores auto-hospedados no GitHub Enterprise Server
Ao usar ações de instalação (como actions/setup-LANGUAGE
) no GitHub Enterprise Server com executores auto-hospedados, talvez seja necessário configurar o cache de ferramentas nos executores que não têm acesso � Internet. Para obter mais informações, confira "Como configurar o cache de ferramentas em executores auto-hospedados sem acesso � Internet".
Usando o fluxo de trabalho inicial do Node.js
GitHub fornece um fluxo de trabalho inicial do Node.js que funcionará para a maioria dos projetos do Node.js. Esse guia inclui exemplos de npm e Yarn que você pode usar para personalizar o fluxo de trabalho inicial. Para obter mais informações, confira o fluxo de trabalho inicial do Node.js.
Para experimentar uma introdução rápida, adicione o fluxo de trabalho inicial ao diretório .github/workflows
do repositório. O fluxo de trabalho mostrado abaixo pressupõe que o branch padrão do repositório seja main
.
name: Node.js CI
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
strategy:
matrix:
node-version: [10.x, 12.x, 14.x, 15.x]
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
- run: npm ci
- run: npm run build --if-present
- run: npm test
Executando em um sistema operacional diferente
O fluxo de trabalho inicial configura os trabalhos a serem executados no Linux usando os executores ubuntu-latest
hospedados no GitHub. Você pode alterar a chave runs-on
para executar seus trabalhos em outro sistema operacional. Por exemplo, você pode usar os GitHub-executores Windows hospedados.
runs-on: windows-latest
Ou, você pode executar nos GitHub-executores do macOS.
runs-on: macos-latest
Você também pode executar tarefas em contêineres Docker, ou você pode fornecer um executor auto-hospedado que funciona na sua própria infraestrutura. Para obter mais informações, confira "Sintaxe de fluxo de trabalho do GitHub Actions".
Especificar a versão do Node.js
A maneira mais fácil de especificar uma versão do Node.js é usando a ação setup-node
fornecida pelo GitHub. Para obter mais informações, confira setup-node
.
A ação setup-node
usa uma versão do Node.js como entrada e configura essa versão no executor. A ação setup-node
localiza uma versão específica do Node.js no cache de ferramentas em cada executor e adiciona os binários necessários a PATH
, que é persistente no restante do trabalho. Usar a ação setup-node
é a maneira recomendada de usar o Node.js com o GitHub Actions, porque garante um comportamento consistente entre diferentes executores e diferentes versões do Node.js. Se você estiver usando um executor auto-hospedado, precisará instalar o Node.js e adicioná-lo a PATH
.
O fluxo de trabalho inicial inclui uma estratégia de matriz que compila e testa seu código com quatro versões do Node.js: 10.x, 12.x, 14.x e 15.x. O "x" é um caractere curinga que corresponde � última versão menor e � versão do patch disponível para uma versão. Cada versão do Node.js especificada na matriz node-version
cria um trabalho que executa as mesmas etapas.
Cada trabalho pode acessar o valor definido na matriz node-version
da matriz usando o contexto matrix
. A ação setup-node
usa o contexto como a entrada de node-version
. A ação setup-node
configura cada trabalho com uma versão diferente do Node.js antes de compilar e testar o código. Para obter mais informações sobre estratégias e contextos de matriz, confira "Sintaxe de fluxo de trabalho do GitHub Actions" e "Contextos".
strategy:
matrix:
node-version: [10.x, 12.x, 14.x, 15.x]
steps:
- uses: actions/checkout@v2
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v2
with:
node-version: ${{ matrix.node-version }}
Como alternativa, você pode criar e fazes testes com versões exatas do Node.js.
strategy:
matrix:
node-version: [8.16.2, 10.17.0]
Você também pode criar e testar usando uma versão única do Node.js.
name: Node.js CI
on: [push]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Use Node.js
uses: actions/setup-node@v2
with:
node-version: '12.x'
- run: npm ci
- run: npm run build --if-present
- run: npm test
Se você não especificar uma versão do Node.js, o GitHub usará a versão-padrão do Node.js do ambiente. Para obter mais informações, confira "Especificações para executores hospedados no GitHub".
Instalar dependências
Executores hospedados em GitHub têm gerenciadores de dependências npm e Yarn instalados. Você pode usar o npm e o Yarn para instalar dependências no seu fluxo de trabalho antes de criar e testar seu código. Os executores do Windows e Linux hospedados em GitHub também têm o Grunt, Gulp, e Bower instalado.
Exemplo de uso do npm
Este exemplo instala as dependências definidas no arquivo package.json. Para obter mais informações, confira npm install
.
steps:
- uses: actions/checkout@v2
- name: Use Node.js
uses: actions/setup-node@v2
with:
node-version: '12.x'
- name: Install dependencies
run: npm install
O uso de npm ci
instala as versões no arquivo package-lock.json ou npm-shrinkwrap.json e impede atualizações no arquivo de bloqueio. O uso de npm ci
geralmente é mais rápido do que a execução de npm install
. Para obter mais informações, confira npm ci
e "Apresentação do npm ci
para builds mais rápidos e confiáveis".
steps:
- uses: actions/checkout@v2
- name: Use Node.js
uses: actions/setup-node@v2
with:
node-version: '12.x'
- name: Install dependencies
run: npm ci
Exemplo de uso do Yarn
Este exemplo instala as dependências definidas no arquivo package.json. Para obter mais informações, confira yarn install
.
steps:
- uses: actions/checkout@v2
- name: Use Node.js
uses: actions/setup-node@v2
with:
node-version: '12.x'
- name: Install dependencies
run: yarn
Como alternativa, você pode transmitir --frozen-lockfile
para instalar as versões no arquivo yarn.lock
e impedir atualizações no arquivo yarn.lock
.
steps:
- uses: actions/checkout@v2
- name: Use Node.js
uses: actions/setup-node@v2
with:
node-version: '12.x'
- name: Install dependencies
run: yarn --frozen-lockfile
Exemplo do uso de um registro privado e de criação o arquivo .npmrc
Você pode usar a ação setup-node
para criar um arquivo .npmrc local no executor que configura o registro e o escopo padrão. A ação setup-node
também aceita um token de autenticação como entrada, usado para acessar registros privados ou publicar pacotes de nós. Para obter mais informações, confira setup-node
.
Para efetuar a autenticação com seu registro privado, você precisará armazenar seu token de autenticação npm como um segredo. Por exemplo, crie um segredo do repositório chamado NPM_TOKEN
. Para obter mais informações, confira "Como criar e usar segredos criptografados".
No exemplo abaixo, o segredo NPM_TOKEN
armazena o token de autenticação do npm. A ação setup-node
configura o arquivo .npmrc para ler o token de autenticação do npm da variável de ambiente NODE_AUTH_TOKEN
. Ao usar a ação setup-node
para criar um arquivo .npmrc, você precisa definir a variável de ambiente NODE_AUTH_TOKEN
com o segredo que contém o token de autenticação do npm.
Antes de instalar as dependências, use a ação setup-node
para criar o arquivo .npmrc. A ação tem dois parâmetros de entrada. O parâmetro node-version
define a versão do Node.js, e o parâmetro registry-url
define o registro padrão. Se o registro de pacote usa escopos, é preciso usar o parâmetro scope
. Para obter mais informações, confira npm-scope
.
steps:
- uses: actions/checkout@v2
- name: Use Node.js
uses: actions/setup-node@v2
with:
always-auth: true
node-version: '12.x'
registry-url: https://registry.npmjs.org
scope: '@octocat'
- name: Install dependencies
run: npm ci
env:
NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
O exemplo acima cria um arquivo .npmrc com o seguinte conteúdo:
//registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN}
@octocat:registry=https://registry.npmjs.org/
always-auth=true
Criar e testar seu código
Você pode usar os mesmos comandos usados localmente para criar e testar seu código. Por exemplo, se você executar npm run build
para executar as etapas de build definidas no arquivo package.json e npm test
para executar o conjunto de testes, adicione esses comandos ao arquivo de fluxo de trabalho.
steps:
- uses: actions/checkout@v2
- name: Use Node.js
uses: actions/setup-node@v2
with:
node-version: '12.x'
- run: npm install
- run: npm run build --if-present
- run: npm test
Empacotar dados do fluxo de trabalho como artefatos
Você pode salvar artefatos das suas etapas de criação e teste para serem visualizados após a conclusão de um trabalho. Por exemplo, é possível que você precise salvar os arquivos de registro, os despejos de núcleo, os resultados de teste ou capturas de tela. Para obter mais informações, confira "Como persistir dados de fluxo de trabalho usando artefatos".
Publicar nos registros do pacote
Você pode configurar o seu fluxo de trabalho para publicar o seu pacote Node.js em um pacote de registro após os seus testes de CI serem aprovados. Para obter mais informações sobre a publicação no npm e no GitHub Packages, confira "Como publicar pacotes do Node.js".