Aspire och Visual Studio Code Utvecklingscontainrar

Dev Containers-tillägget Visual Studio Code är ett sätt för utvecklingsteam att utveckla i en containerbaserad miljö där alla beroenden är förkonfigurerade. Med Aspire 9.1 har logik lagts till för bättre stöd för att arbeta med Aspire i en Dev Container-miljö genom att automatiskt konfigurera portvidarebefordring.

Före Aspire 9.1 gick det att använda Aspire i en Dev Container, men mer manuell konfiguration krävdes.

Dev Containers jämfört med GitHub Codespaces

Att använda Dev Containers i Visual Studio Code liknar att använda GitHub Codespaces. Med versionen av Aspire 9.1 har stödet för både Dev Containers i Visual Studio Code och GitHub Codespaces förbättrats. Även om upplevelserna är liknande finns det vissa skillnader. Mer information om hur du använder Aspire med GitHub Codespaces finns i Aspire och GitHub Codespaces.

Snabbstart med malllagringsplats

Om du vill konfigurera Dev Containers i Visual Studio Codeanvänder du filen _.devcontainer/devcontainer.json på lagringsplatsen. Det enklaste sättet att komma igång är genom att skapa en ny lagringsplats från vår malllagringsplats. Överväg följande steg:

1. Skapa en ny lagringsplats med hjälp av vår mall.

   

   När du har angett informationen och valt Skapa lagringsplats skapas lagringsplatsen och visas i GitHub.

2. Klona lagringsplatsen till din lokala arbetsstation för utvecklare med hjälp av följande kommando:

   git clone https://github.com/<org>/<username>/<repository>
   

3. Öppna lagringsplatsen i Visual Studio Code. Efter en liten stund identifierar Visual Studio Code.devcontainer/devcontainer.json-filen och uppmanar att öppna arkivet i en container. Välj det alternativ som passar bäst för arbetsflödet.

   

   Efter en liten stund blir listan med filer synlig och den lokala versionen av utvecklingscontainern slutförs.

   

4. Öppna ett nytt terminalfönster i Visual Studio Code (Ctrl+Skift+`) och skapa ett nytt Aspire projekt med hjälp av kommandoraden dotnet .

   dotnet new aspire-starter -n HelloAspire
   

   Efter en liten stund skapas projektet och de inledande beroendena återställs.

5. Öppna filen ProjectName.AppHost/AppHost.cs i redigeraren och välj knappen Kör i det övre högra hörnet i redigeringsfönstret.

   

   Visual Studio Code skapar och startar Aspire AppHost och öppnar Aspire instrumentpanelen automatiskt. Eftersom slutpunkterna som finns i containern använder ett självsignerat certifikat första gången du får åtkomst till en slutpunkt för en specifik Dev Container, visas ett certifikatfel.

   

   Certifikatfelet förväntas. När du har bekräftat att url:en som begärs motsvarar instrumentpanelen i Dev Container kan du ignorera den här varningen.

   

   Aspire konfigurerar automatiskt vidarebefordrade portar så att när du väljer slutpunkterna på Aspire instrumentpanelen dirigeras de till processer och kapslade containrar inom Dev Container.

6. Checka in ändringar i lagringsplatsen GitHub

   När du har skapat Aspire projektet och kontrollerat att det startas och du har åtkomst till instrumentpanelen är det en bra idé att genomföra ändringarna på lagringsplatsen.

Konfigurera devcontainer.json manuellt

Föregående genomgång visar den effektiva processen att skapa en Dev Container med hjälp av mallen Aspire Dev Container. Om du redan har en befintlig lagringsplats och vill använda Dev Container-funktioner med Aspirelägger du till en devcontainer.json fil i mappen .devcontainer på lagringsplatsen:

└───📂 .devcontainer
     └─── devcontainer.json

Mallförvaret innehåller en kopia av devcontainer.json-filen som du kan använda som utgångspunkt, vilket bör vara tillräckligt för Aspire. Följande JSON representerar den senaste versionen av .devcontainer/devcontainer.json-filen från mallen:

// For format details, see https://aka.ms/devcontainer.json. For config options, see the
// README at: https://github.com/devcontainers/templates/tree/main/src/dotnet
{
    "name": ".NET Aspire",
    // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
    "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
    "features": {
        "ghcr.io/devcontainers/features/docker-in-docker:2": {},
        "ghcr.io/devcontainers/features/powershell:1": {},
    },

    "hostRequirements": {
        "cpus": 8,
        "memory": "32gb",
        "storage": "64gb"
    },

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

    // Use 'postCreateCommand' to run commands after the container is created.
    // "postCreateCommand": "dotnet restore",
    "onCreateCommand": "curl -sSL https://aspire.dev/install.sh | bash",
    "postStartCommand": "dotnet dev-certs https --trust",
    "customizations": {
        "vscode": {
            "extensions": [
                "ms-dotnettools.csdevkit",
                "GitHub.copilot-chat",
                "GitHub.copilot"
            ]
        }
    }
    // Configure tool-specific properties.
    // "customizations": {},

    // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
    // "remoteUser": "root"
}

Utvecklingscontainerscenarier

Den grundläggande Aspire Dev Container-mallen fungerar bra för enkla scenarier, men du kan behöva ytterligare konfiguration beroende på dina specifika krav. Följande avsnitt innehåller exempel på olika vanliga scenarier.

Endast tillståndslösa .NET appar

För enkla Aspire projekt som bara använder .NET projektresurser utan externa containrar eller komplex orkestrering kan du använda en minimal Dev Container-konfiguration:

{
  "name": "Aspire - Simple",
  "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
  "onCreateCommand": "dotnet new install Aspire.ProjectTemplates --force",
  "postStartCommand": "dotnet dev-certs https --trust",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-dotnettools.csdevkit"
      ]
    }
  }
}

Den här minimala konfigurationen är lämplig för Aspire appar som endast .NET samordnar tjänster utan externa beroenden.

Lägga till Node.js resurser

Om din Aspire app innehåller Node.js resurser, lägger du till funktionen till din Node.js Dev Container:

{
  "name": "Aspire with Node.js",
  "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/node:1": {
      "version": "lts"
    }
  },
  "onCreateCommand": "dotnet new install Aspire.ProjectTemplates --force",
  "postStartCommand": "dotnet dev-certs https --trust",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-dotnettools.csdevkit",
        "ms-vscode.vscode-typescript-next"
      ]
    }
  }
}

Den här konfigurationen ger både .NET och Node.js utvecklingsfunktioner i samma containermiljö.

Containerorkestrering med Docker-in-Docker

När din Aspire-app orkestrerar containerresurser behöver du Docker-i-Docker-stöd (DinD). Här är en grundläggande konfiguration:

{
  "name": "Aspire with Containers",
  "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/docker-in-docker:2": {
      "version": "latest",
      "enableNonRootDocker": true,
      "moby": true
    }
  },
  "hostRequirements": {
    "cpus": 4,
    "memory": "16gb",
    "storage": "32gb"
  },
  "onCreateCommand": "dotnet new install Aspire.ProjectTemplates --force",
  "postStartCommand": "dotnet dev-certs https --trust",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-dotnettools.csdevkit",
        "ms-azuretools.vscode-docker"
      ]
    }
  }
}

Avancerat containernätverk

Om du stöter på nätverksproblem mellan containrar eller behöver IPv6-stöd kan du lägga till ytterligare nätverkskonfiguration:

{
  "name": "Aspire with Advanced Networking",
  "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/docker-in-docker:2": {
      "version": "latest",
      "enableNonRootDocker": true,
      "moby": true
    }
  },
  "runArgs": [
    "--sysctl",
    "net.ipv6.conf.all.disable_ipv6=0",
    "--sysctl",
    "net.ipv6.conf.default.forwarding=1",
    "--sysctl",
    "net.ipv6.conf.all.forwarding=1"
  ],
  "hostRequirements": {
    "cpus": 8,
    "memory": "32gb",
    "storage": "64gb"
  },
  "onCreateCommand": "dotnet new install Aspire.ProjectTemplates --force",
  "postStartCommand": "dotnet dev-certs https --trust",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-dotnettools.csdevkit",
        "ms-azuretools.vscode-docker"
      ]
    }
  }
}

Dapr integrationsexempel

För Aspire appar som integreras med Daprkan du konfigurera Dapr komponenter i din Dev Container. Mer information finns i AspireDapr integrering.

Grundläggande Dapr konfiguration

{
  "name": "Aspire with Dapr",
  "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/docker-in-docker:2": {
      "enableNonRootDocker": true
    },
    "ghcr.io/dapr/cli/dapr-cli:0": {}
  },
  "onCreateCommand": "dotnet new install Aspire.ProjectTemplates --force",
  "postCreateCommand": "dotnet dev-certs https --trust && dapr init",
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-dotnettools.csdevkit",
        "ms-azuretools.vscode-dapr"
      ]
    }
  }
}

Dapr med externa serverdelar

För mer komplexa Dapr scenarier som använder externa serverdelar (Redis, PostgreSQL), kan du använda Docker Compose:

{
  "name": "Aspire with Dapr and Backends",
  "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/docker-in-docker:2": {
      "enableNonRootDocker": true
    },
    "ghcr.io/dapr/cli/dapr-cli:0": {}
  },
  "runArgs": [
    "--sysctl",
    "net.ipv6.conf.all.disable_ipv6=0"
  ],
  "onCreateCommand": "dotnet new install Aspire.ProjectTemplates --force",
  "postCreateCommand": [
    "dotnet dev-certs https --trust",
    "docker compose up -d",
    "dapr init"
  ],
  "customizations": {
    "vscode": {
      "extensions": [
        "ms-dotnettools.csdevkit",
        "ms-azuretools.vscode-dapr",
        "ms-azuretools.vscode-docker"
      ]
    }
  }
}

Vanliga överväganden

Tänk på följande när du använder Dev Containers med Aspire:

Resurskrav

• Grundläggande .NET appar: Standard Dev Container-resurser räcker för enkla scenarier.
• Containerorkestrering: Minst 8 processorer, 32 GB minne och 64 GB lagring rekommenderas.
• Komplexa scenarier med Dapr/Kubernetes: Högre resursallokering rekommenderas för optimala prestanda.

Nätverk

• IPv6-konfiguration kan krävas för kommunikation mellan containrar.
• Portvidarebefordring hanteras automatiskt av Aspire 9.1 och senare versioner.
• Anslutning till den externa tjänsten beror på din konfigurationsinställning för kontainerkörningsmiljön.

Föreställning

• Docker-in-Docker scenarier medför prestandaförluster jämfört med ursprungliga Docker.
• Överväg att använda Docker utanför Docker (DooD) för produktionsarbetsflöden.
• Scenarier för lokal utveckling och distribution kan kräva olika konfigurationer.

Säkerhet

• Dev Containers körs med förhöjd behörighet när du använder Docker-in-Docker.
• SSL-certifikatförtroende hanteras automatiskt i de flesta scenarier.
• Överväg säkerhetskonsekvenser när du exponerar portar i molnmiljöer.

Se även

• Aspire och GitHub Codespaces
• Aspire Dapr integration
• Lägga till Dockerfiles i din .NET appmodell
• Dev Containers-specifikation