Sdílet prostřednictvím

Aspire a Visual Studio Code vývojové kontejnery

Rozšíření Dev Containers Visual Studio Code poskytuje vývojové týmy způsob vývoje v rámci kontejnerizovaného prostředí, kde jsou předkonfigurované všechny závislosti. Ve verzi Aspire 9.1 byla přidána logika pro lepší podporu práce v prostředí vývojového kontejneru, která automaticky konfiguruje přesměrování portů.

Před Aspire 9.1 je možné použít Aspire v rámci vývojového kontejneru, ale vyžadovala se ruční konfigurace.

Dev Containers vs. GitHub Codespaces

Použití Dev Containers ve Visual Studio Code je podobné použití v GitHub Codespaces. Uvedením verze Aspire 9.1 byla vylepšena podpora jak pro Dev Containers v Visual Studio Code, tak i pro GitHub Codespaces. I když jsou prostředí podobné, existují určité rozdíly. Další informace o použití Aspire s GitHub Codespaces najdete v tématu Aspire a GitHub Codespaces.

Rychlý start s využitím úložiště šablon

Ke konfiguraci dev Containers v Visual Studio Codeúložišti použijte soubor _.devcontainer/devcontainer.json. Nejjednodušší způsob, jak začít, je vytvoření nového úložiště z našeho úložiště šablony. Zvažte následující kroky:

  1. Vytvořte nové úložiště pomocí naší šablony.

    Vytvořte nové úložiště.

    Jakmile zadáte podrobnosti a vyberete Vytvořit úložiště, vytvoří se úložiště a zobrazí se v GitHubsouboru .

  2. Naklonujte úložiště do místní vývojářské pracovní stanice pomocí následujícího příkazu:

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

  3. Otevřete úložiště v Visual Studio Code. Po chvíli Visual Studio Code zjistí soubor .devcontainer/devcontainer.json a zobrazí výzvu k otevření úložiště v kontejneru. Vyberte, která možnost je nejvhodnější pro váš pracovní postup.

    Výzva k otevření úložiště uvnitř kontejneru

    Po chvíli se seznam souborů zobrazí a dokončí se místní sestavení vývojového kontejneru.

    Sestavení vývojového kontejneru bylo dokončeno.

  4. Otevřete nové okno terminálu v Visual Studio Code aplikaci (Ctrl+Shift+`) a vytvořte nový Aspire projekt pomocí příkazového dotnet řádku.

    dotnet new aspire-starter -n HelloAspire

    Po chvíli se projekt vytvoří a obnoví se počáteční závislosti.

  5. Otevřete soubor ProjectName.AppHost/AppHost.cs v editoru a vyberte tlačítko spustit v pravém horním rohu okna editoru.

    Tlačítko Spustit v editoru

    Visual Studio Code sestaví a spustí Aspire AppHost a automaticky otevře Aspire řídicí panel. Vzhledem k tomu, že koncové body hostované v kontejneru používají samopodepsaný certifikát, při prvním přístupu ke koncovému bodu konkrétního vývojového kontejneru se zobrazí chyba certifikátu.

    Chyba certifikátu prohlížeče

    Očekává se chyba certifikátu. Jakmile ověříte, že požadovaná adresa URL odpovídá řídicímu panelu v vývojovém kontejneru, můžete toto upozornění ignorovat.

    Aspire řídicí panel spuštěný ve vývojovém kontejneru

    Aspire automaticky nakonfiguruje přesměrované porty, takže když vyberete koncové body na panelu Aspire, budou směrovány na procesy a vnořené kontejnery v rámci Dev kontejneru.

  6. Potvrzení změn do GitHub úložiště

    Po úspěšném vytvoření Aspire projektu a ověření, že se spustí a máte přístup k řídicímu panelu, je vhodné potvrdit změny v úložišti.

Ruční konfigurace devcontainer.json

Předchozí názorný postup ukazuje zjednodušený proces vytvoření vývojového kontejneru pomocí Aspire šablony Dev Container. Pokud už máte existující úložiště a chcete využívat funkce dev Container s Aspire, přidejte do složky .devcontainer v úložišti soubordevcontainer.json:

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

Úložiště šablony obsahuje kopii souborudevcontainer.json , který můžete použít jako výchozí bod, který by měl být dostatečný pro Aspire. Následující JSON příklad představuje nejnovější verzi souboru .devcontainer/devcontainer.json ze šablony:

// 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": "Aspire",
    // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
    "image": "mcr.microsoft.com/devcontainers/dotnet:dev-10.0-noble",
    "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"
}

Scénáře vývojových kontejnerů

Základní Aspire šablona vývojového kontejneru funguje dobře pro jednoduché scénáře, ale možná budete potřebovat další konfiguraci v závislosti na konkrétních požadavcích. Následující části obsahují příklady pro různé běžné scénáře.

Pouze bezstavové .NET aplikace

U jednoduchých Aspire projektů, které používají .NET pouze prostředky projektu bez externích kontejnerů nebo složité orchestrace, můžete použít minimální konfiguraci vývojového kontejneru:

{
  "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"
      ]
    }
  }
}

Tato minimální konfigurace je vhodná pro Aspire aplikace, které orchestrují pouze .NET služby bez externích závislostí.

Přidání Node.js prostředků

Pokud vaše Aspire aplikace obsahuje Node.js prostředky, přidejte tuto funkci do vývojového Node.js kontejneru:

{
  "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"
      ]
    }
  }
}

Tato konfigurace poskytuje možnosti vývoje jak .NET, tak Node.js v rámci stejného prostředí kontejneru.

Orchestrace kontejnerů pomocí - Dockerin-Docker

Když vaše Aspire aplikace orchestruje prostředky kontejneru, potřebujete Dockerpodporu -in-Docker (DinD). Tady je základní konfigurace:

{
  "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"
      ]
    }
  }
}

Pokročilé síťování kontejnerů

Pokud narazíte na problémy se sítí mezi kontejnery nebo potřebujete podporu protokolu IPv6, můžete přidat další konfiguraci sítě:

{
  "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"
      ]
    }
  }
}

Důležité

Docker-in-Docker Úvahy:

  • Docker-in-Docker vyžaduje vyšší přidělení prostředků, což zahrnuje zvýšené využití procesoru, paměti a úložiště.
  • Výše uvedená pokročilá síťová konfigurace zahrnuje nastavení předávání IPv6, která mohou být potřebná pro komplexní scénáře komunikace typu kontejner-kontejner.
  • Tato konfigurace funguje s Desktopem Docker , ale může mít omezení u Rancher Desktopu.
  • Síťové připojení mezi kontejnery může vyžadovat další konfiguraci v závislosti na konkrétním případu použití.

Dapr Příklady integrace

Pro Aspire aplikace, které se integrují s Dapr, můžete nastavit komponenty Dapr ve vývojovém kontejneru. Další informace najdete v tématu AspireDapr Integrace.

Základní Dapr nastavení

{
  "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 s externími backendy

Pro složitější Dapr scénáře, které používají externí back-endy (Redis, PostgreSQL), můžete použít 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"
      ]
    }
  }
}

Běžné úvahy

Při použití dev Containers s Aspiremějte na paměti následující aspekty:

Požadavky na prostředky

  • Základní aplikace: Prostředky .NETstandardního vývojového kontejneru jsou dostatečné pro jednoduché scénáře.
  • Orchestrace kontejnerů: Doporučuje se minimálně 8 procesorů, 32 GB paměti a 64 GB úložiště.
  • Pro složité scénáře s Dapr/Kubernetes, je doporučeno vyšší přidělení prostředků pro zajištění optimálního výkonu.

Síťování

  • Pro komunikaci typu kontejner-kontejner může být vyžadována konfigurace protokolu IPv6.
  • Přesměrování portů se automaticky zpracovává ve Aspire verzi 9.1 a novějších verzích.
  • Připojení externí služby závisí na konfiguraci modulu runtime kontejneru.

výkon

  • Docker-in-Docker scénáře způsobují režijní zatížení výkonu v porovnání s nativními Docker.
  • Zvažte použití Docker mimo Docker (DooD) pro produkční pracovní postupy.
  • Místní scénáře vývoje a nasazení můžou vyžadovat různé konfigurace.

Zabezpečení

  • Dev Containers běží se zvýšenými oprávněními při použití příkazu Docker-in-Docker.
  • Ve většině scénářů se důvěryhodnost certifikátů SSL řeší automaticky.
  • Při zveřejňování portů v cloudových prostředích zvažte dopad na zabezpečení.

Viz také

  • Last updated on