Sdílet prostřednictvím

Nasazení Dockeru

Návod

I když znáte Docker nebo Orleans, doporučujeme tento článek přečíst do konce, abyste se vyhnuli potenciálním problémům se známými alternativními řešeními.

Tento článek a její ukázka představují probíhající práci. Vítáme názory, žádosti o přijetí změn nebo návrhy.

Nasazení Orleans řešení do Dockeru

Nasazení Orleans do Dockeru může být složité kvůli návrhu orchestrátorů Dockeru a zásobníků clusteringu. Nejkomplikovanější část je pochopení konceptu překryvné sítě z DockerU Swarm a síťového modelu Kubernetes.

Kontejnery a síťové modely Dockeru byly primárně navržené pro spouštění bezstavových a neměnných kontejnerů. Zprovoznění clusteru se spuštěnými aplikacemi Node.js nebo Nginx je poměrně snadné. Použití něčeho složitějšího, jako je skutečně clusterovaná nebo distribuovaná aplikace (například založená na Orleans), však může představovat potíže s nastavením. Je to možné, ale ne tak jednoduché jako nasazení webových aplikací.

Clustering Dockeru zahrnuje seskupení několika hostitelů, aby fungovalo jako jeden fond zdrojů spravovaný pomocí nástroje Container Orchestrator. Docker Inc. poskytuje jako svou možnost Swarm , zatímco Google nabízí Kubernetes (označované také jako K8s). Existují další orchestrátory, jako DC/OS a Mesos, ale tento dokument se zaměřuje na Swarm a K8s, protože jsou častěji používané.

Stejná rozhraní a implementace, které běží kdekoli Orleans , se podporují také v kontejnerech Dockeru. Ke spuštění Orleans aplikace v kontejnerech Dockeru nejsou potřeba žádné zvláštní aspekty.

Zde probírané koncepty platí pro verze Orleans rozhraní .NET Core i .NET Framework 4.6.1. Pro ilustraci multiplatformní povahy Dockeru a .NET Core jsou však zaměřeny na příklady využití .NET Core. V případě potřeby je možné poskytnout podrobnosti specifické pro konkrétní platformu (Windows/Linux/macOS).

Požadavky

Tento článek předpokládá, že jsou nainstalovány následující požadavky:

  • Docker: Docker4X má snadno použitelný instalační program pro hlavní podporované platformy. Obsahuje modul Docker a Docker Swarm.
  • Kubernetes (K8s): Nabídka orchestrace kontejnerů Google. Obsahuje pokyny pro instalaci Minikube (místní nasazení K8s) a kubectl spolu se závislostmi.
  • .NET: Multiplatformní varianta rozhraní .NET.
  • Visual Studio Code (VSCode): Můžete použít libovolné upřednostňované integrované vývojové prostředí (IDE). VSCode se zde používá, protože se jedná o multiplatformní platformu a zajišťuje, aby příklady fungovaly na všech platformách. Po instalaci VSCode nainstalujte rozšíření C#.

Důležité

Pokud ji nepoužíváte, instalace Kubernetes se nevyžaduje. Instalační program Docker4X už obsahuje Swarm, takže pro Swarm není nutná žádná další instalace.

Poznámka:

Na Windows aktivuje instalační program Dockeru během instalace Hyper-V. Vzhledem k tomu, že tento článek a jeho příklady používají .NET Core, jsou použité image kontejnerů založené na Windows Serveru NanoServer. Pokud místo toho plánujete používat rozhraní .NET Framework 4.6.1, použijte image založené na rozhraní Windows Server Core a Orleans verzi 1.4+ (která podporuje pouze rozhraní .NET Framework).

Vytvořte Orleans řešení

Následující pokyny ukazují, jak vytvořit standardní Orleans řešení pomocí dotnet nástrojů.

Upravte příkazy podle potřeby pro platformu. Adresářová struktura je jen návrh; přizpůsobit ho podle potřeby.

mkdir Orleans-Docker
cd Orleans-Docker
dotnet new sln
mkdir -p src/OrleansSilo
mkdir -p src/OrleansClient
mkdir -p src/OrleansGrains
mkdir -p src/OrleansGrainInterfaces
dotnet new console -o src/OrleansSilo --framework netcoreapp1.1
dotnet new console -o src/OrleansClient --framework netcoreapp1.1
dotnet new classlib -o src/OrleansGrains --framework netstandard1.5
dotnet new classlib -o src/OrleansGrainInterfaces --framework netstandard1.5
dotnet sln add src/OrleansSilo/OrleansSilo.csproj
dotnet sln add src/OrleansClient/OrleansClient.csproj
dotnet sln add src/OrleansGrains/OrleansGrains.csproj
dotnet sln add src/OrleansGrainInterfaces/OrleansGrainInterfaces.csproj
dotnet add src/OrleansClient/OrleansClient.csproj reference src/OrleansGrainInterfaces/OrleansGrainInterfaces.csproj
dotnet add src/OrleansSilo/OrleansSilo.csproj reference src/OrleansGrainInterfaces/OrleansGrainInterfaces.csproj
dotnet add src/OrleansGrains/OrleansGrains.csproj reference src/OrleansGrainInterfaces/OrleansGrainInterfaces.csproj
dotnet add src/OrleansSilo/OrleansSilo.csproj reference src/OrleansGrains/OrleansGrains.csproj

Zatím byl vytvořen pouze standardní kód pro strukturu řešení a samotné projekty, a byly mezi nimi přidány reference. To se nijak neliší od nastavení běžného Orleans projektu.

V době psaní Orleans tohoto článku byla verze 2.0 (podpora vývoje pro .NET Core a multiplatformní vývoj) ve verzi Technology Preview. Jeho balíčky NuGet byly hostovány v úložišti MyGet, ne v oficiálním úložišti NuGet.org. Pokud chcete nainstalovat balíčky NuGet ve verzi Preview, použijte dotnet rozhraní příkazového řádku, které vynutí zdrojový kanál a verzi z MyGet:

dotnet add src/OrleansClient/OrleansClient.csproj package Microsoft.Orleans.Core -s https://dotnet.myget.org/F/orleans-prerelease/api/v3/index.json -v 2.0.0-preview2-201705020000
dotnet add src/OrleansGrainInterfaces/OrleansGrainInterfaces.csproj package Microsoft.Orleans.Core -s https://dotnet.myget.org/F/orleans-prerelease/api/v3/index.json -v 2.0.0-preview2-201705020000
dotnet add src/OrleansGrains/OrleansGrains.csproj package Microsoft.Orleans.Core -s https://dotnet.myget.org/F/orleans-prerelease/api/v3/index.json -v 2.0.0-preview2-201705020000
dotnet add src/OrleansSilo/OrleansSilo.csproj package Microsoft.Orleans.Core -s https://dotnet.myget.org/F/orleans-prerelease/api/v3/index.json -v 2.0.0-preview2-201705020000
dotnet add src/OrleansSilo/OrleansSilo.csproj package Microsoft.Orleans.OrleansRuntime -s https://dotnet.myget.org/F/orleans-prerelease/api/v3/index.json -v 2.0.0-preview2-201705020000
dotnet restore

Dobře, všechny základní závislosti pro spuštění jednoduché Orleans aplikace jsou teď na místě. Všimněte si, že v tomto okamžiku se nic nezměnilo z běžného Orleans nastavení aplikace. Teď přidáme nějaký kód, aby byl funkční.

Implementujte aplikaci Orleans

Za předpokladu, že se používá VSCode , spusťte code . z adresáře řešení. Tento příkaz otevře adresář ve VSCode a načte řešení.

Toto je struktura řešení vytvořená dříve.

Visual Studio Code: Průzkumník s vybranou Program.cs.

Program.cs, OrleansHostWrapper.cs, IGreetingGrain.cs a GreetingGrain.cs soubory byly také přidány do projektů rozhraní a grain projektů. Tady je kód těchto souborů:

IGreetingGrain.cs:

using System;
using System.Threading.Tasks;
using Orleans;

namespace OrleansGrainInterfaces
{
    public interface IGreetingGrain : IGrainWithGuidKey
    {
        Task<string> SayHello(string name);
    }
}

GreetingGrain.cs:

using System;
using System.Threading.Tasks;
using OrleansGrainInterfaces;

namespace OrleansGrains
{
    public class GreetingGrain : Grain, IGreetingGrain
    {
        public Task<string> SayHello(string name)
        {
            return Task.FromResult($"Hello from Orleans, {name}");
        }
    }
}

OrleansHostWrapper.cs:

using System;
using System.NET;
using Orleans.Runtime;
using Orleans.Runtime.Configuration;
using Orleans.Runtime.Host;

namespace OrleansSilo;

public class OrleansHostWrapper
{
    private readonly SiloHost _siloHost;

    public OrleansHostWrapper(ClusterConfiguration config)
    {
        _siloHost = new SiloHost(Dns.GetHostName(), config);
        _siloHost.LoadOrleansConfig();
    }

    public int Run()
    {
        if (_siloHost is null)
        {
            return 1;
        }

        try
        {
            _siloHost.InitializeOrleansSilo();

            if (_siloHost.StartOrleansSilo())
            {
                Console.WriteLine(
                    $"Successfully started Orleans silo '{_siloHost.Name}' as a {_siloHost.Type} node.");
                return 0;
            }
            else
            {
                throw new OrleansException(
                    $"Failed to start Orleans silo '{_siloHost.Name}' as a {_siloHost.Type} node.");
            }
        }
        catch (Exception exc)
        {
            _siloHost.ReportStartupError(exc);
            Console.Error.WriteLine(exc);

            return 1;
        }
    }

    public int Stop()
    {
        if (_siloHost is not null)
        {
            try
            {
                _siloHost.StopOrleansSilo();
                _siloHost.Dispose();
                Console.WriteLine($"Orleans silo '{_siloHost.Name}' shutdown.");
            }
            catch (Exception exc)
            {
                siloHost.ReportStartupError(exc);
                Console.Error.WriteLine(exc);

                return 1;
            }
        }
        return 0;
    }
}

Program.cs (sil):

using System;
using System.Collections.Generic;
using System.Linq;
using System.NET;
using System.Threading.Tasks;
using Orleans.Runtime.Configuration;

namespace OrleansSilo
{
    public class Program
    {
        private static OrleansHostWrapper s_hostWrapper;

        static async Task<int> Main(string[] args)
        {
            int exitCode = await InitializeOrleansAsync();

            Console.WriteLine("Press Enter to terminate...");
            Console.ReadLine();

            exitCode += ShutdownSilo();

            return exitCode;
        }

        private static int InitializeOrleansAsync()
        {
            var config = new ClusterConfiguration();
            config.Globals.DataConnectionString =
                "[AZURE STORAGE CONNECTION STRING HERE]";
            config.Globals.DeploymentId = "Orleans-Docker";
            config.Globals.LivenessType =
                GlobalConfiguration.LivenessProviderType.AzureTable;
            config.Globals.ReminderServiceType =
                GlobalConfiguration.ReminderServiceProviderType.AzureTable;
            config.Defaults.PropagateActivityId = true;
            config.Defaults.ProxyGatewayEndpoint =
                new IPEndPoint(IPAddress.Any, 10400);
            config.Defaults.Port = 10300;
            var ips = await Dns.GetHostAddressesAsync(Dns.GetHostName());
            config.Defaults.HostNameOrIPAddress =
                ips.FirstOrDefault()?.ToString();

            s_hostWrapper = new OrleansHostWrapper(config);
            return hostWrapper.Run();
        }

        static int ShutdownSilo() =>
            s_hostWrapper?.Stop() ?? 0;
    }
}

Program.cs (klient):

using System;
using System.NET;
using System.Threading;
using System.Threading.Tasks;
using Orleans;
using Orleans.Runtime.Configuration;
using OrleansGrainInterfaces;

namespace OrleansClient
{
    class Program
    {
        private static IClusterClient s_client;
        private static bool s_running;

        static async Task Main(string[] args)
        {
            await InitializeOrleansAsync();

            Console.ReadLine();

            s_running = false;
        }

        static async Task InitializeOrleansAsync()
        {
            var config = new ClientConfiguration
            {
                DeploymentId = "Orleans-Docker";
                PropagateActivityId = true;
            };
            var hostEntry =
                await Dns.GetHostEntryAsync("orleans-silo");
            var ip = hostEntry.AddressList[0];
            config.Gateways.Add(new IPEndPoint(ip, 10400));

            Console.WriteLine("Initializing...");

            using client = new ClientBuilder().UseConfiguration(config).Build();
            await client.Connect();
            s_running = true;
            Console.WriteLine("Initialized!");

            var grain = client.GetGrain<IGreetingGrain>(Guid.Empty);

            while (s_running)
            {
                var response = await grain.SayHello("Gutemberg");
                Console.WriteLine($"[{DateTime.UtcNow}] - {response}");

                await Task.Delay(1000);
            }
        }
    }
}

Podrobnosti o implementaci zde nejsou popsané, protože jsou mimo zaměření tohoto článku. Další informace najdete v dalších relevantních dokumentech. Tyto soubory představují minimální Orleans aplikaci, která slouží jako výchozí bod pro zbytek tohoto článku.

Tento článek používá OrleansAzureUtils zprostředkovatele členství, ale můžete použít jiného podporovaného Orleansposkytovatele.

Soubor Dockerfile

Docker používá k vytváření kontejnerů image. Další podrobnosti o vytváření vlastních imagí najdete v dokumentaci k Dockeru. Tento článek používá oficiální snímky Microsoftu. Na základě cílových a vývojových platforem vyberte příslušnou image. microsoft/dotnet:1.1.2-sdk, zde se používá image založená na Linuxu. Pro Windows microsoft/dotnet:1.1.2-sdk-nanoserver je například možné použít. Vyberte si ten, který vyhovuje potřebám.

Poznámka pro uživatele Windows: Jak už jsme zmínili dříve, pro zajištění kompatibility mezi platformami se v tomto článku používají .NET Core a Orleans Technical Preview 2.0. Pokud chcete používat Docker na Windows s oficiálně vydanými Orleans verzemi 1.4 nebo novější, použijte image založené na Windows Server Core, jelikož image NanoServeru a Linuxu podporují jenom .NET Core.

Dockerfile.debug:

FROM microsoft/dotnet:1.1.2-sdk
ENV NUGET_XMLDOC_MODE skip
WORKDIR /vsdbg
RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        unzip \
    && rm -rf /var/lib/apt/lists/* \
    && curl -sSL https://aka.ms/getvsdbgsh | bash /dev/stdin -v latest -l /vsdbg
WORKDIR /app
ENTRYPOINT ["tail", "-f", "/dev/null"]

Tento soubor Dockerfile v podstatě stáhne a nainstaluje ladicí program VSdbg a spustí prázdný kontejner, který zůstává trvale aktivní, takže jej při ladění není nutné opakovaně vypínat a zapínat.

V produkčním prostředí je teď image menší, protože obsahuje pouze modul runtime .NET Core, nikoli celou sadu SDK. Soubor Dockerfile je také jednodušší:

Soubor Dockerfile:

FROM microsoft/dotnet:1.1.2-runtime
WORKDIR /app
ENTRYPOINT ["dotnet", "OrleansSilo.dll"]
COPY . /app

Soubor docker-compose

Soubor docker-compose.yml definuje sadu služeb a jejich závislosti v rámci projektu na úrovni služby. Každá služba obsahuje jednu nebo více instancí daného kontejneru na základě imagí vybraných v souboru Dockerfile. Další podrobnosti najdete docker-compose v dokumentaci k docker-compose.

U nasazení Orleans obvyklý případ použití zahrnuje soubor docker-compose.yml obsahující dvě služby: jednu pro Silo Orleans a druhou pro Klienta Orleans. Klientská Služba závisí na Službě Silo, což znamená, že se spustí až po spuštění Služby Silo. Dalším scénářem může být přidání úložiště nebo databázové služby či kontejneru (například SQL Serveru), který by měl být spuštěn před klientem i silo. V tomto případě by klientské i silové služby závisely na databázové službě.

Poznámka:

Než se pustíte do dalšího čtení, mějte na paměti, že na odsazení opravdu záleží v docker-compose souborech. Věnujte pozornost tomu, pokud dojde k problémům.

Zde je popis služeb v tomto článku:

docker-compose.override.yml (ladění):

version: '3.1'

services:
  orleans-client:
    image: orleans-client:debug
    build:
      context: ./src/OrleansClient/bin/PublishOutput/
      dockerfile: Dockerfile.Debug
    volumes:
      - ./src/OrleansClient/bin/PublishOutput/:/app
      - ~/.nuget/packages:/root/.nuget/packages:ro
    depends_on:
      - orleans-silo
  orleans-silo:
    image: orleans-silo:debug
    build:
      context: ./src/OrleansSilo/bin/PublishOutput/
      dockerfile: Dockerfile.Debug
    volumes:
      - ./src/OrleansSilo/bin/PublishOutput/:/app
      - ~/.nuget/packages:/root/.nuget/packages:ro

docker-compose.yml (produkční):

version: '3.1'

services:
  orleans-client:
    image: orleans-client
    depends_on:
      - orleans-silo
  orleans-silo:
    image: orleans-silo

V produkčním prostředí není místní adresář mapován a ani není zahrnuta akce build:. Důvodem je, že v produkčním prostředí by se image měly sestavit a odeslat do privátního registru Dockeru.

Spojte všechno dohromady

Teď, když jsou všechny potřebné komponenty připravené, pojďme je dát dohromady a spustit řešení uvnitř Dockeru Orleans .

Důležité

Následující příkazy by se měly provádět z adresáře řešení.

Nejprve se ujistěte, že jsou obnoveny všechny balíčky NuGet pro řešení. Je třeba provést pouze jednou, pokud se nezmění závislosti balíčku.

dotnet restore

Teď sestavte řešení pomocí rozhraní příkazového dotnet řádku jako obvykle a publikujte ho do výstupního adresáře:

dotnet publish -o ./bin/PublishOutput

Návod

publish se zde používá místo build toho, aby se zabránilo problémům s dynamicky načtenými sestaveními v Orleans. Stále se snažíme najít lepší řešení.

Se sestavenou a publikovanou aplikací sestavte image Dockeru pomocí souborů Dockerfile. Tento krok obvykle potřebuje provést pouze jednou pro každý projekt. Je třeba ji znovu potřebovat, pouze pokud se soubor Dockerfile nebo docker-compose změní, nebo pokud se místní registr imagí z nějakého důvodu vyčistí.

docker-compose build

Všechny základní image používané v obou Dockerfile a docker-compose.yml jsou staženy z registru a uloženy v mezipaměti na vývojovém počítači. Image aplikací jsou vytvořené a všechno je připravené ke spuštění.

Teď spustíme aplikaci.

# docker-compose up -d
Creating network "orleansdocker_default" with the default driver
Creating orleansdocker_orleans-silo_1 ...
Creating orleansdocker_orleans-silo_1 ... done
Creating orleansdocker_orleans-client_1 ...
Creating orleansdocker_orleans-client_1 ... done
#

docker-compose ps Spuštění teď ukazuje dva kontejnery spuštěné pro orleansdocker projekt:

# docker-compose ps
             Name                     Command        State   Ports
------------------------------------------------------------------
orleansdocker_orleans-client_1   tail -f /dev/null   Up
orleansdocker_orleans-silo_1     tail -f /dev/null   Up

Poznámka:

Pokud používáte Windows a kontejner používá základní image Windows, zobrazí se ve sloupci Command ekvivalentní příkaz PowerShell pro systémy *NIX, což zajistí, že bude kontejner běžet podobně.

Teď, když jsou kontejnery spuštěné, jejich zastavení není nutné při každém Orleans spuštění aplikace. Stačí integrovat integrované vývojové prostředí pro ladění aplikace uvnitř kontejneru, který byl dříve namapován v docker-compose.yml.

Škálování

Jakmile se compose projekt spustí, můžete snadno škálovat aplikaci pomocí docker-compose scale příkazem:

# docker-compose scale orleans-silo=15
Starting orleansdocker_orleans-silo_1 ... done
Creating orleansdocker_orleans-silo_2 ...
Creating orleansdocker_orleans-silo_3 ...
Creating orleansdocker_orleans-silo_4 ...
Creating orleansdocker_orleans-silo_5 ...
Creating orleansdocker_orleans-silo_6 ...
Creating orleansdocker_orleans-silo_7 ...
Creating orleansdocker_orleans-silo_8 ...
Creating orleansdocker_orleans-silo_9 ...
Creating orleansdocker_orleans-silo_10 ...
Creating orleansdocker_orleans-silo_11 ...
Creating orleansdocker_orleans-silo_12 ...
Creating orleansdocker_orleans-silo_13 ...
Creating orleansdocker_orleans-silo_14 ...
Creating orleansdocker_orleans-silo_15 ...
Creating orleansdocker_orleans-silo_6
Creating orleansdocker_orleans-silo_5
Creating orleansdocker_orleans-silo_3
Creating orleansdocker_orleans-silo_2
Creating orleansdocker_orleans-silo_4
Creating orleansdocker_orleans-silo_9
Creating orleansdocker_orleans-silo_7
Creating orleansdocker_orleans-silo_8
Creating orleansdocker_orleans-silo_10
Creating orleansdocker_orleans-silo_11
Creating orleansdocker_orleans-silo_15
Creating orleansdocker_orleans-silo_12
Creating orleansdocker_orleans-silo_14
Creating orleansdocker_orleans-silo_13

Po několika sekundách se služby škálují na konkrétní požadovaný počet instancí.

# docker-compose ps
             Name                     Command        State   Ports
------------------------------------------------------------------
orleansdocker_orleans-client_1   tail -f /dev/null   Up
orleansdocker_orleans-silo_1     tail -f /dev/null   Up
orleansdocker_orleans-silo_10    tail -f /dev/null   Up
orleansdocker_orleans-silo_11    tail -f /dev/null   Up
orleansdocker_orleans-silo_12    tail -f /dev/null   Up
orleansdocker_orleans-silo_13    tail -f /dev/null   Up
orleansdocker_orleans-silo_14    tail -f /dev/null   Up
orleansdocker_orleans-silo_15    tail -f /dev/null   Up
orleansdocker_orleans-silo_2     tail -f /dev/null   Up
orleansdocker_orleans-silo_3     tail -f /dev/null   Up
orleansdocker_orleans-silo_4     tail -f /dev/null   Up
orleansdocker_orleans-silo_5     tail -f /dev/null   Up
orleansdocker_orleans-silo_6     tail -f /dev/null   Up
orleansdocker_orleans-silo_7     tail -f /dev/null   Up
orleansdocker_orleans-silo_8     tail -f /dev/null   Up
orleansdocker_orleans-silo_9     tail -f /dev/null   Up

Důležité

Sloupec Command v těchto příkladech ukazuje tail příkaz, protože se používá kontejner ladicího programu. V produkci by se například zobrazovalo dotnet OrleansSilo.dll.

Docker Swarm

Zásobník clusteringu Dockeru se nazývá Swarm. Další informace najdete v tématu Docker Swarm.

Ke spuštění aplikace popsané v tomto článku v clusteru Swarm není potřeba žádná další práce. Spouštění docker-compose up -d na uzlech Swarm plánuje kontejnery na základě nakonfigurovaných pravidel. Totéž platí pro další služby založené na Swarm, jako je Azure Kubernetes Service (AKS) (v režimu Swarm) a AWS Elastic Container Service (ECS). Nasadit Swarm cluster před nasazením dockerizovanéOrleans aplikace.

Poznámka:

Pokud používáte modul Docker s podporou stackrežimu Swarm , deploya compose v3, lepší přístup k nasazení řešení je docker stack deploy -c docker-compose.yml <name>. Mějte na paměti, že to vyžaduje soubor v3 compose kompatibilní s modulem Dockeru. Řada hostovaných služeb, jako je Azure a AWS, stále používá verze 2 a starší moduly.

Google Kubernetes (K8s)

Pokud plánujete používat Kubernetes k hostování Orleans, je poskytovatel clusteringu spravovaný komunitou dostupný na webu OrleansContrib\Orleans. Clustering.Kubernetes. Tady najdete dokumentaci a ukázky pro hostování Orleans v Kubernetes bez problémů pomocí poskytovatele.

Ladění Orleans uvnitř kontejnerů

Nyní, když se pochopí, jak provozovat Orleans v kontejneru od začátku, je užitečné využít jeden z nejdůležitějších principů Dockeru: neměnnost. Kontejnery by měly mít (téměř) stejný obraz, závislosti a runtime během vývoje stejně jako v produkci. Tento postup pomáhá zabránit klasickému problému "Funguje na mém počítači!" . Aby to bylo možné, je potřeba vytvořit uvnitř kontejneru způsob, jak připojit ladicí program k aplikaci spuštěné uvnitř.

Existuje několik způsobů, jak toho dosáhnout pomocí různých nástrojů. Po vyhodnocení několika možností v době psaní textu se jedna, která se zdá jednodušší a méně rušivá pro aplikaci, byla vybrána.

Jak už bylo zmíněno dříve, VSCode se používá k vývoji ukázky. Takto můžete připojit ladicí program k Orleans aplikaci uvnitř kontejneru:

Nejprve v řešení upravte dva soubory v .vscode adresáři:

tasks.json:

{
    "version": "0.1.0",
    "command": "dotnet",
    "isShellCommand": true,
    "args": [],
    "tasks": [
        {
            "taskName": "publish",
            "args": [
                "${workspaceRoot}/Orleans-Docker.sln", "-c", "Debug", "-o", "./bin/PublishOutput"
            ],
            "isBuildCommand": true,
            "problemMatcher": "$msCompile"
        }
    ]
}

Tento soubor v podstatě říká VSCode, že pokaždé, když se projekt sestavuje, se spustí příkaz publish, podobně jako byl spuštěn ručně dříve.

launch.json:

{
   "version": "0.2.0",
   "configurations": [
        {
            "name": "Silo",
            "type": "coreclr",
            "request": "launch",
            "cwd": "/app",
            "program": "/app/OrleansSilo.dll",
            "sourceFileMap": {
                "/app": "${workspaceRoot}/src/OrleansSilo"
            },
            "pipeTransport": {
                "debuggerPath": "/vsdbg/vsdbg",
                "pipeProgram": "/bin/bash",
                "pipeCwd": "${workspaceRoot}",
                "pipeArgs": [
                    "-c",
                    "docker exec -i orleansdocker_orleans-silo_1 /vsdbg/vsdbg --interpreter=vscode"
                ]
            }
        },
        {
            "name": "Client",
            "type": "coreclr",
            "request": "launch",
            "cwd": "/app",
            "program": "/app/OrleansClient.dll",
            "sourceFileMap": {
                "/app": "${workspaceRoot}/src/OrleansClient"
            },
            "pipeTransport": {
                "debuggerPath": "/vsdbg/vsdbg",
                "pipeProgram": "/bin/bash",
                "pipeCwd": "${workspaceRoot}",
                "pipeArgs": [
                    "-c",
                    "docker exec -i orleansdocker_orleans-client_1 /vsdbg/vsdbg --interpreter=vscode"
                ]
            }
        }
    ]
}

Nyní sestavte řešení z VSCode (které se také publikuje) a spusťte jak konfiguraci Silo, tak konfiguraci klienta. VSCode odešle docker exec příkaz do spuštěné docker-compose instance služby nebo kontejneru, který spustí ladicí program připojený k aplikaci. To je to! Debugger je připojený ke kontejneru a dá se použít stejně jako ladění místně spuštěné Orleans aplikace. Klíčovým rozdílem je, že aplikace běží uvnitř kontejneru. Po dokončení vývoje publikujte image kontejneru do registru a přetáhněte ji do hostitelů Dockeru v produkčním prostředí.