Configurando seu projeto C# (.NET) para os codespaces

Primeiros passos com o seu projeto C# (.NET) em Codespaces criando um contêiner de desenvolvimento personalizado.

Codespaces is available for organizations using GitHub Team or GitHub Enterprise Cloud. Para obter mais informações, consulte os "produtos do GitHub".

Introdução

Este guia mostra como configurar seu projeto C# (.NET) em Codespaces. Ele irá apresentar a você um exemplo de abertura de seu projeto em um codespace e adicionar e modificar uma configuração de contêiner de desenvolvimento a partir de um modelo.

Pré-requisitos

  • Você deve ter um projeto C# (.NET) existente em um repositório em GitHub.com. Se você não tiver um projeto, você poderá tentar este tutorial com o seguinte exemplo: https://github.com/2percentsilk/dotnet-quickstart.
  • Você precisa ter Codespaces habilitado para a sua organização.

Etapa 1: Abra o seu projeto em um codespace

  1. No nome do repositório, use o menu suspenso Código de e na aba Codespaces de código, clique em Novo codespace.

    Botão de codespace novo

    Se você não vir esta opção, significa que Codespaces não está disponível para o seu projeto. Consulte Acesso a Codespaces para mais informações.

Ao criar um código, seu projeto será criado em uma VM remota dedicada a você. Por padrão, o contêiner para o seu codespace têm várias linguagens e tempos de execução, incluindo .NET. Ele também inclui um conjunto comum de ferramentas, como git, wget, rsync, openssh e nano.

Você pode personalizar o seu codespace ajustando a quantidade de vCPUs e RAM, adicionando dotfiles para personalizar seu ambienteou modificando as ferramentas e scripts instalados.

Codespaces usa um arquivo denominado devcontainer.json para armazenar configurações. Ao iniciar, Codespaces usa o arquivo para instalar quaisquer ferramentas, dependências ou outro conjunto que possa ser necessário para o projeto. Para obter mais informações, consulte "Introdução a contêineres de desenvolvimento".

Etapa 2: Adicione um contêiner de desenvolvimento ao seu codespace a partir de um modelo

O contêiner de codespaces padrão vem com a versão mais recente do .NET e as ferramentas mais comuns pré-instaladas. No entanto, recomendamos que você configure um contêiner personalizado para que possa personalizar as ferramentas e scripts que são executados como parte da criação do codespace para as necessidades do seu projeto e garantir um ambiente reprodutível para todos os usuários de Codespaces no seu repositório.

Para configurar seu projeto com um contêiner personalizado, você deverá usar um arquivo devcontainer.json para definir o ambiente. Em Codespaces, você pode adicionar isto a partir de um modelo ou você pode criar o seu próprio. Para obter mais informações sobre contêineres de desenvolvimento, consulte "Introdução a contêineres de desenvolvimento ".

  1. Access the Paleta de Comando do VS Code (Shift + Command + P / Ctrl + Shift + P), then start typing "dev container". Selecione Codespaces: Adicionar arquivos de configuração de Contêiner do Desenvolvimento....

    "Codespaces: Add Development Container Configuration Files..." in the Paleta de Comando do VS Code

  2. Para este exemplo, clique em C# (.NET). Se você precisar de funcionalidades adicionais, você poderá selecionar qualquer contêiner específico para o C# (.NET) ou uma combinação de ferramentas como C# (.NET) e MS SQL. Selecione a opção C# (.NET) na lista

  3. Clique na versão recomendada do .NET. Seleção da versão .NET

  4. Aceite a opção padrão para adicionar Node.js à sua personalização. Adicionar seleção de Node.js

  5. Access the Paleta de Comando do VS Code (Shift + Command + P/ Ctrl + Shift + P), then start typing "rebuild". Selecione Codespaces: Reconstruir Contêiner.

    Opção de reconstruir contêiner

Anatomia do seu contêiner de desenvolvimento

A adição do modelo de contêiner de C# (.NET) adiciona uma pasta de contêiner de desenvolvimento .devcontainer à raiz do repositório do seu projeto com os seguintes arquivos:

  • devcontainer.json
  • arquivo Docker

O arquivo recém-adicionado devcontainer.json define algumas propriedades que são descritas após a amostra.

devcontainer.json

{
    "name": "C# (.NET)",
    "build": {
        "dockerfile": "Dockerfile",
        "args": {
            // Update 'VARIANT' to pick a .NET Core version: 2.1, 3.1, 5.0
            "VARIANT": "5.0",
            // Options
            "INSTALL_NODE": "true",
            "NODE_VERSION": "lts/*",
            "INSTALL_AZURE_CLI": "false"
        }
    },

    // Set *default* container specific settings.json values on container create.
    "settings": {
        "terminal.integrated.shell.linux": "/bin/bash"
    },

    // Add the IDs of extensions you want installed when the container is created.
    "extensions": [
        "ms-dotnettools.csharp"
    ],

    // Use 'forwardPorts' to make a list of ports inside the container available locally.
    // "forwardPorts": [5000, 5001],

    // [Optional] To reuse of your local HTTPS dev cert:
    //
    // 1. Export it locally using this command:
    //    * Windows PowerShell:
    //        dotnet dev-certs https --trust; dotnet dev-certs https -ep "$env:USERPROFILE/.aspnet/https/aspnetapp.pfx" -p "SecurePwdGoesHere"
    //    * macOS/Linux terminal:
    //        dotnet dev-certs https --trust; dotnet dev-certs https -ep "${HOME}/.aspnet/https/aspnetapp.pfx" -p "SecurePwdGoesHere"
    //
    // 2. Uncomment these 'remoteEnv' lines:
    //    "remoteEnv": {
    //        "ASPNETCORE_Kestrel__Certificates__Default__Password": "SecurePwdGoesHere",
    //        "ASPNETCORE_Kestrel__Certificates__Default__Path": "/home/vscode/.aspnet/https/aspnetapp.pfx",
    //    },
    //
    // 3. Do one of the following depending on your scenario:
    //    * When using GitHub Codespaces and/or Remote - Containers:
    //      1. Start the container
    //      2. Drag ~/.aspnet/https/aspnetapp.pfx into the root of the file explorer
    //      3. Open a terminal in VS Code and run "mkdir -p /home/vscode/.aspnet/https && mv aspnetapp.pfx /home/vscode/.aspnet/https"
    //
    //    * If only using Remote - Containers with a local container, uncomment this line instead:
    //      "mounts": [ "source=${env:HOME}${env:USERPROFILE}/.aspnet/https,target=/home/vscode/.aspnet/https,type=bind" ],

    // Use 'postCreateCommand' to run commands after the container is created.
    // "postCreateCommand": "dotnet restore",

    // Comment out connect as root instead. Mais informações: https://aka.ms/vscode-remote/containers/non-root.
    "remoteUser": "vscode"
}
  • Nome - Você pode dar qualquer nome ao nosso contêiner de desenvolvimento. Este é apenas o padrão.
  • Build - As propriedades de compilação.
    • Arquivo Docker - No objeto de compilação, arquivo Docker é uma referência ao arquivo arquivo Docker que também foi adicionado a partir do template.
    • Args
      • Variante: Este arquivo contém apenas um argumento de compilação, que é a versão do .NET Core que queremos usar.
  • Configurações - Estas são as configurações de Visual Studio Code.
    • Terminal.integrated.shell.linux - Embora o bash seja o padrão, você pode usar outros shells do terminal, fazendo a modificação.
  • Extensões - Estas são extensões incluídas por padrão.
    • ms-dotnettools.csharp - A extensão Microsoft C# fornece amplo suporte para o desenvolvimento em C#, incluindo funcionalidades como IntelliSense, links, depuração, navegação de código, formatação de código, refatoração, explorador de variáveis, explorador de testes e muito mais.
  • forwardPorts - Todas as portas listadas aqui serão encaminhadas automaticamente. Para obter mais informações, consulte "Encaminhando portas no seu codespace".
  • postCreateCommand - Se você quiser executar qualquer coisa depois de parar no seu codespace, isso não estará definido no arquivo Docker como a Dotnet restore. Você pode fazer isso aqui.
  • remoteUser - Por padrão, você está executando como usuário do vscode, mas, opcionalmente, você pode definir isso como root.

arquivo Docker

# [Choice] .NET version: 5.0, 3.1, 2.1
ARG VARIANT="5.0"
FROM mcr.microsoft.com/vscode/devcontainers/dotnetcore:0-${VARIANT}

# [Option] Install Node.js
ARG INSTALL_NODE="true"
ARG NODE_VERSION="lts/*"
RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi

# [Option] Install Azure CLI
ARG INSTALL_AZURE_CLI="false"
COPY library-scripts/azcli-debian.sh /tmp/library-scripts/
RUN if [ "$INSTALL_AZURE_CLI" = "true" ]; then bash /tmp/library-scripts/azcli-debian.sh; fi \
    && apt-get clean -y && rm -rf /var/lib/apt/lists/* /tmp/library-scripts

# [Optional] Uncomment this section to install additional OS packages.
# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
#     && apt-get -y install --no-install-recommends <your-package-list-here>

# [Optional] Uncomment this line to install global node packages.
# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1

Você pode usar o arquivo Docker para adicionar camadas adicionais de contêiner para especificar os pacotes do OS, versões de nó ou pacotes globais que queremos que sejam incluídos no nosso contêiner.

Etapa 3: Modifique seu arquivo devcontainer.json

Com o seu contêiner de desenvolvimento adicionado e um entendimento básico do que tudo faz, agora você pode fazer alterações para configurá-lo para o seu ambiente. Neste exemplo, você irá adicionar propriedades para instalar extensões e restaurar as dependências do seu projeto quando seu codespace for iniciado.

  1. No Explorador, expanda a pasta .devcontainer e selecione o arquivo devcontainer.json a partir da árvore para abri-lo.

    Arquivo devcontainer.json no Explorador

  2. Atualize a sua lista de extensões no seu arquivo devcontainer.json para adicionar algumas extensões úteis ao trabalhar com o seu projeto.

    JSON
    "extensions": [
            "ms-dotnettools.csharp",
            "streetsidesoftware.code-spell-checker",
        ],
  3. Remova o comentário o postCreateCommand para restaurar as dependências como parte do processo de configuração do codespace.

    JSON
    // Use 'postCreateCommand' para executar os comandos após a criação do contêiner.
    "postCreateCommand": "dotnet restore",
  4. Access the Paleta de Comando do VS Code (Shift + Command + P/ Ctrl + Shift + P), then start typing "rebuild". Selecione Codespaces: Reconstruir Contêiner.

    Opção de reconstruir contêiner

    A reconstrução dentro do seu codespace garante que as suas alterações funcionem conforme o esperado antes de realizar o commit das alterações no repositório. Se algo falhar, você será colocado em um codespace com um contêiner de recuperação que você pode reconstruir para continuar ajustando o seu contêiner.

  5. Verifique se suas alterações foram aplicadas com sucesso verificando se a extensão "Code Spell Checker" foi instalada.

    Lista de extensões

Etapa 4: Execute o seu aplicativo

Na seção anterior, você usou o postCreateCommand para instalar um conjunto de pacotes por meio do comando dotnet restore. Com nossas dependências agora instaladas, podemos executar nosso aplicativo.

  1. Execute seu aplicativo pressionando F5 ou inserindo dotnet watch run no seu terminal.

  2. Quando o seu projeto for iniciado, você deverá ver um alerta no canto inferior direito com uma instrução para conectar-se à porta que seu projeto usa.

    Notificação de encaminhamento de porta

Etapa 5: Faça commit das suas alterações

Depois de realizar alterações no seu código, tanto novo código como de configuração, você deverá fazer commit das suas alterações. O commit das alterações no seu repositório garante que qualquer pessoa que crie um codespace deste repositório tenha a mesma configuração. Isto também significa que qualquer personalização que você faça, como adicionar extensões deVisual Studio Code, aparecerá para todos os usuários.

Para obter informações, consulte "Usando o controle de fonte no seu codespace".

Próximas etapas

Agora você deve estar pronto para começar a desenvolver seu projeto C# (.NET) em Codespaces. Aqui estão alguns recursos adicionais para cenários mais avançados.

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.