Udostępnij przez

Aspire i Visual Studio Code Kontenery Dev

Rozszerzenie Dev Containers Visual Studio Code umożliwia zespołom deweloperów opracowywanie w środowisku konteneryzowanym, w którym wszystkie zależności są wstępnie skonfigurowane. W wersji Aspire 9.1 dodano logikę, aby ulepszyć obsługę w środowisku Aspire kontenera deweloperskiego, automatycznie konfigurując przekazywanie portów.

Przed Aspire 9.1 można użyć Aspire w kontenerze deweloperskim, jednak wymagana była bardziej ręczna konfiguracja.

Kontenery deweloperskie a GitHub Codespaces

Używanie usługi Dev Containers w systemie Visual Studio Code jest podobne do używania usługi GitHub Codespaces. W wersji Aspire 9.1 rozszerzono obsługę kontenerów deweloperskich w systemach Visual Studio Code i GitHub Codespaces. Chociaż doświadczenia są podobne, istnieją pewne różnice. Aby uzyskać więcej informacji na temat używania Aspire z GitHub Codespaces, zobacz Aspire i GitHub Codespaces.

Szybki start przy użyciu repozytorium szablonów

Aby skonfigurować kontenery deweloperskie w programie Visual Studio Code, użyj pliku _.devcontainer/devcontainer.json w repozytorium. Najprostszym sposobem rozpoczęcia pracy jest utworzenie nowego repozytorium na bazie naszego repozytorium szablonu. Rozważ następujące kroki:

  1. Utwórz nowe repozytorium przy użyciu naszego szablonu.

    Utwórz nowe repozytorium.

    Po podaniu szczegółów i wybraniu polecenia Utwórz repozytorium, repozytorium zostanie utworzone i wyświetlone w GitHub.

  2. Sklonuj repozytorium na lokalną stację roboczą dewelopera przy użyciu następującego polecenia:

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

  3. Otwórz repozytorium w pliku Visual Studio Code. Po kilku chwilach Visual Studio Code wykryje plik devcontainer/devcontainer.json i wyświetli monit o otwarcie repozytorium wewnątrz kontenera. Wybierz dowolną opcję, która jest najbardziej odpowiednia dla przepływu pracy.

    Polecenie do otwarcia repozytorium wewnątrz kontenera.

    Po kilku chwilach lista plików stanie się widoczna i zostanie ukończona lokalna kompilacja kontenera deweloperskiego.

    Kompilacja kontenera deweloperskiego została ukończona.

  4. Otwórz nowe okno terminalu w Visual Studio Code (Ctrl+Shift+`) i utwórz nowy projekt Aspire przy użyciu wiersza polecenia dotnet.

    dotnet new aspire-starter -n HelloAspire

    Po kilku chwilach projekt zostanie utworzony i przywrócone początkowe zależności.

  5. Otwórz plik ProjectName.AppHost/AppHost.cs w edytorze i wybierz przycisk uruchamiania w prawym górnym rogu okna edytora.

    Przycisk Uruchom w edytorze.

    Visual Studio Code kompiluje i uruchamia aplikację Aspire AppHost i automatycznie otwiera Aspire pulpit nawigacyjny. Ponieważ punkty końcowe hostowane w kontenerze używają certyfikatu z podpisem własnym, przy pierwszym dostępie do punktu końcowego dla określonego kontenera deweloperskiego pojawia się błąd certyfikatu.

    Błąd certyfikatu przeglądarki.

    Oczekiwany jest błąd certyfikatu. Po potwierdzeniu, że żądany adres URL odpowiada pulpitowi nawigacyjnemu w kontenerze deweloperskim, możesz zignorować to ostrzeżenie.

    Aspire pulpit nawigacyjny uruchomiony w kontenerze deweloperskim.

    Aspire Automatycznie konfiguruje przekierowane porty tak, aby po wybraniu Aspire punktów końcowych na pulpicie nawigacyjnym były tunelowane do procesów i zagnieżdżonych kontenerów w kontenerze deweloperskim.

  6. Zatwierdź zmiany w repozytorium GitHub

    Po pomyślnym utworzeniu projektu Aspire i upewnieniu się, że został uruchomiony i można uzyskać dostęp do pulpitu nawigacyjnego, dobrym pomysłem jest zatwierdzenie zmian w repozytorium.

Ręczne konfigurowanie devcontainer.json

W poprzednim przewodniku przedstawiono usprawniony proces tworzenia kontenera deweloperskiego przy użyciu szablonu Aspire Dev Container. Jeśli masz już istniejące repozytorium i chcesz korzystać z funkcji kontenera deweloperskiego z Aspire, dodaj plik devcontainer.json do folderu .devcontainer w repozytorium.

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

Repozytorium szablonów zawiera kopię pliku devcontainer.json, którego można użyć jako punktu początkowego, który powinien być wystarczający dla elementu Aspire. JSON Poniżej przedstawiono najnowszą wersję pliku .devcontainer/devcontainer.json z szablonu:

// 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": {},
        "ghcr.io/devcontainers/features/node:1": {},
        "ghcr.io/devcontainers/features/python:1": {},
        "ghcr.io/devcontainers-extra/features/uv: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"
}

Scenariusze kontenera deweloperskiego

Podstawowy Aspire szablon kontenera deweloperskiego działa dobrze w przypadku prostych scenariuszy, ale w zależności od określonych wymagań może być potrzebna dodatkowa konfiguracja. W poniższych sekcjach przedstawiono przykłady różnych typowych scenariuszy.

Tylko aplikacje bezstanowe .NET

W przypadku prostych Aspire projektów, które wykorzystują tylko zasoby projektu .NET bez kontenerów zewnętrznych lub złożonej orkiestracji, można użyć minimalnej konfiguracji kontenera deweloperskiego.

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

Ta minimalna konfiguracja jest odpowiednia dla Aspire aplikacji, które organizuje tylko .NET usługi bez zależności zewnętrznych.

Dodawanie Node.js zasobów

Jeśli aplikacja Aspire zawiera Node.js zasoby, dodaj tę funkcję Node.js do kontenera deweloperskiego.

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

Ta konfiguracja zapewnia zarówno możliwości programistyczne .NET, jak i Node.js w tym samym środowisku kontenera.

Orkiestracja kontenerów z wykorzystaniem Docker-in-Docker

Gdy aplikacja Aspire zarządza zasobami kontenerów, potrzebna jest obsługa funkcji Docker-in-Docker (DinD). Oto podstawowa konfiguracja:

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

Zaawansowana sieć kontenerów

Jeśli wystąpią problemy z siecią między kontenerami lub potrzebujesz obsługi protokołu IPv6, możesz dodać dodatkową konfigurację sieci:

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

Ważne

Docker-in-Docker zagadnienia:

  • Docker-inDocker wymaga wyższej alokacji zasobów, w tym zwiększenia użycia procesora, pamięci i pamięci masowej.
  • Powyższa zaawansowana konfiguracja sieci obejmuje ustawienia przekazywania IPv6, które mogą być potrzebne w przypadku złożonych scenariuszy komunikacji między kontenerami.
  • Ta konfiguracja działa z Docker programem Desktop, ale może mieć ograniczenia dotyczące programu Rancher Desktop.
  • Łączność sieciowa między kontenerami może wymagać dodatkowej konfiguracji w zależności od konkretnego przypadku użycia.

Dapr przykłady integracji

W przypadku Aspire aplikacji integrujących się Dapr z usługą Daprmożna skonfigurować składniki w kontenerze deweloperskim. Aby uzyskać więcej informacji, zobacz AspireDapr integracja.

Konfiguracja podstawowa Dapr

{
  "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 z zewnętrznymi backendami

W przypadku bardziej złożonych Dapr scenariuszy korzystających z zewnętrznych back-endów (Redis, PostgreSQL), można użyć 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"
      ]
    }
  }
}

Typowe zagadnienia

W przypadku korzystania z usługi Dev Containers z usługą Aspirenależy pamiętać o następujących kwestiach:

Wymagania dotyczące zasobów

  • Podstawowe .NET aplikacje: zasoby standardowego kontenera deweloperskiego są wystarczające dla prostych scenariuszy.
  • Orkiestracja kontenerów: zalecane jest co najmniej 8 procesorów CPU, 32 GB pamięci i 64 GB pamięci.
  • Złożone scenariusze z Dapr/Kubernetes: Wyższa alokacja zasobów jest zalecana w celu uzyskania optymalnej wydajności.

Sieć komputerowa

  • Konfiguracja protokołu IPv6 może być wymagana do komunikacji między kontenerami.
  • Przekazywanie portów jest obsługiwane automatycznie przez Aspire 9.1 i nowsze wersje.
  • Łączność z usługą zewnętrzną zależy od konfiguracji środowiska uruchomieniowego kontenera.

Wydajność

  • Docker-in-Docker scenariusze powodują obciążenie związane z wydajnością w porównaniu z natywnym Docker.
  • Rozważ użycie Docker poza Docker (DooD) dla przepływów pracy w produkcji.
  • Scenariusze programowania i wdrażania lokalnego mogą wymagać różnych konfiguracji.

Bezpieczeństwo

  • Kontenery deweloperskie są uruchamiane z podwyższonymi przywilejami podczas używania Docker-in-Docker.
  • Zaufanie certyfikatu SSL jest obsługiwane automatycznie w większości scenariuszy.
  • Podczas uwidaczniania portów w środowiskach chmury należy wziąć pod uwagę implikacje dotyczące zabezpieczeń.

Zobacz także

  • Last updated on