Observação: GitHub Actions estava disponível para GitHub Enterprise Server 2.22 como um beta limitado. O beta terminou. GitHub Actions está agora geralmente disponível em GitHub Enterprise Server 3.0 ou posterior. Para obter mais informações, consulte as observações sobre a versão GitHub Enterprise Server 3.0.
- Para obter mais informações sobre a atualização para GitHub Enterprise Server 3.0 ou posterior, consulte "Atualizar GitHub Enterprise Server".
- Para obter mais informações sobre a configuração de GitHub Actions após atualizar, consulte a documentação para GitHub Enterprise Server 3.0.
Observação: Executores hospedados em GitHub não são atualmente compatíveis com GitHub Enterprise Server. Você pode ver mais informações sobre suporte futuro planejado no Itinerário público do GitHub.
Introdução
Este guia mostra como criar, testar e publicar um pacote no .NET.
GitHub têm um cache de ferramentas com software pré-instalado, que inclui o SDK Core do .NET. Para uma lista completa de software atualizado e as versões pré-instaladas do .NET Core SDK, consulte o software instalado nos executores hospedados em GitHub.
Pré-requisitos
Você já deve estar familiarizado com a sintaxe YAML e como é usado com GitHub Actions. Para obter mais informações, consulte "Workflow syntax for GitHub Actions."
Recomendamos que você tenha um entendimento básico do .NET Core SDK. Para obter mais informações, consulte Primeiros passos com o .NET.
Começando com o modelo do fluxo de trabalho do .NET
GitHub fornece um modelo de fluxo de trabalho do .NET que deve funcionar para a maioria dos projetos .NET e este guia inclui exemplos que mostram como personalizar este modelo. Para obter mais informações, consulte o modelo do fluxo de trabalho do .NET.
Para iniciar rapidamente, adicione o modelo ao diretório .github/workflows
do repositório.
name: dotnet package
on: [push]
jobs:
build:
runs-on: ubuntu-latest
strategy:
matrix:
dotnet-version: ['3.0', '3.1.x', '5.0.x' ]
steps:
- uses: actions/checkout@v2
- name: Setup .NET Core SDK ${{ matrix.dotnet-version }}
uses: actions/setup-dotnet@v1.7.2
with:
dotnet-version: ${{ matrix.dotnet-version }}
- name: Install dependencies
run: dotnet restore
- name: Build
run: dotnet build --configuration Release --no-restore
- name: Test
run: dotnet test --no-restore --verbosity normal
Especificando uma versão do .NET
Para usar uma versão pré-instalada do .NET Core SDK em um executor hospedado em GitHub, use a ação setup-dotnet
. Esta ação encontra uma versão específica do .NET do cache de ferramentas em cada executor e adiciona os binários necessários para PATH
. Estas alterações persistirão para o resto do trabalho.
A ação setup-dotnet
é a forma recomendada de usar .NET com GitHub Actions, porque garante um comportamento consistente em executores diferentes e versões diferentes do .NET. Se você estiver usando um executor auto-hospedado, você deverá instalar o .NET e adicioná-lo ao PATH
. Para obter mais informações, consulte a ação setup-dotnet
.
Usar múltiplas versões do .NET
name: dotnet package
on: [push]
jobs:
build:
runs-on: ubuntu-latest
strategy:
matrix:
dotnet: [ '3.0', '3.1.x', '5.0.x' ]
steps:
- uses: actions/checkout@v2
- name: Setup dotnet ${{ matrix.dotnet-version }}
uses: actions/setup-dotnet@v1
with:
dotnet-version: ${{ matrix.dotnet-version }}
# You can test your matrix by printing the current dotnet version
- name: Display dotnet version
run: dotnet --version
Usar uma versão específica do .NET
Você pode configurar o seu trabalho para usar uma versão específica do .NET, como 3.1.3
. Como alternativa, você pode usar a sintaxe da versão semântica para obter a última versão secundária. Este exemplo usa a versão mais recente do .NET 3.
- name: Setup .NET 3.x
uses: actions/setup-dotnet@v1
with:
# Semantic version range syntax or exact version of a dotnet version
dotnet-version: '3.x'
Instalar dependências
Os executores hospedados em GitHub têm o gerenciador do pacote NuGet instalado. Você pode usar o dotnet CLI para instalar dependências do registro do pacote NuGet antes de criar e testar seu código. Por exemplo, o YAML abaixo instala o pacote Newtonsoft
.
steps:
- uses: actions/checkout@v2
- name: Setup dotnet
uses: actions/setup-dotnet@v1
with:
dotnet-version: '3.1.x'
- name: Install dependencies
run: dotnet add package Newtonsoft.Json --version 12.0.1
Criar e testar seu código
Você pode usar os mesmos comandos usados localmente para criar e testar seu código. Este exemplo demonstra como usar a dotnet build
e o dotnet test
em um trabalho:
steps:
- uses: actions/checkout@v2
- name: Setup dotnet
uses: actions/setup-dotnet@v1
with:
dotnet-version: '3.1.x'
- name: Install dependencies
run: dotnet restore
- name: Build
run: dotnet build
- name: Test with the dotnet CLI
run: dotnet test
Empacotar dados do fluxo de trabalho como artefatos
Após a conclusão de um fluxo de trabalho, você poderá fazer o upload dos artefatos resultantes para análise. 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. O exemplo a seguir demonstra como você pode usar a ação upload-artefato
para fazer o upload de resultados de testes.
Para obter mais informações, consulte "Dados recorrentes do fluxo de trabalho que usam artefatos".
name: dotnet package
on: [push]
jobs:
build:
runs-on: ubuntu-latest
strategy:
matrix:
dotnet-version: [ '3.0', '3.1.x', '5.0.x' ]
steps:
- uses: actions/checkout@v2
- name: Setup dotnet
uses: actions/setup-dotnet@v1
with:
dotnet-version: ${{ matrix.dotnet-version }}
- name: Install dependencies
run: dotnet restore
- name: Test with dotnet
run: dotnet test --logger trx --results-directory "TestResults-${{ matrix.dotnet-version }}"
- name: Upload dotnet test results
uses: actions/upload-artifact@v2
with:
name: dotnet-results-${{ matrix.dotnet-version }}
path: TestResults-${{ matrix.dotnet-version }}
# Use always() to always run this step to publish test results when there are test failures
if: ${{ always() }}
Publicar nos registros do pacote
É possível configurar o seu fluxo de trabalho para publicar o pacote Dotnet em um pacote de registro quando o CI teste passa. Você pode usar segredos do repositório para armazenar quaisquer tokens ou credenciais necessárias para publicar seu binário. O exemplo a seguir cria e publica um pacote em GitHub Package Registry usando dotnet core cli
.
name: Upload dotnet package
on:
release:
types: [created]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/setup-dotnet@v1
with:
dotnet-version: '3.1.x' # SDK Version to use.
source-url: https://nuget.pkg.github.com/<owner>/index.json
env:
NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
- run: dotnet build --configuration Release <my project>
- name: Create the package
run: dotnet pack --configuration Release <my project>
- name: Publish the package to GPR
run: dotnet nuget push <my project>/bin/Release/*.nupkg