Megosztás a következőn keresztül:

Docker üzembe helyezése

  • Cikk

Tipp.

Még ha ismeri is a Dockert vagy Orleans, javasoljuk, hogy olvassa el ezt a cikket a végéig, hogy elkerülje a kerülő megoldásokkal kapcsolatos problémákat.

Ez a cikk és a minta egy folyamatban lévő munka. Bármilyen visszajelzést, pr-t vagy javaslatot szívesen fogadunk.

Megoldások üzembe helyezése Orleans a Dockerben

Orleans A Dockerben való üzembe helyezés bonyolult lehet, mivel a Docker-vezénylőket és a fürtözési vermeket úgy tervezték meg. A legbonyolultabb dolog a Docker Swarm és a Kubernetes hálózati modell átfedésmentes hálózatának fogalma.

A Docker-tárolók és a hálózati modellek többnyire állapot nélküli és nem módosítható tárolók futtatására lettek tervezve. Így a node.js vagy Nginx-alkalmazásokat futtató fürtök létrehozása meglehetősen egyszerű. Ha azonban valami összetettebbet próbál használni, például egy valódi fürtözött vagy elosztott alkalmazást (például Orleans-alapúakat), akkor végül problémába fog keveredni a beállításával. Lehetséges, de nem olyan egyszerű, mint a webes alkalmazások.

A Docker-fürtözés több gazdagép összevonásából áll, hogy egyetlen erőforráskészletként működjön, egy tárolóvezénylővel felügyelve. Docker Inc. adja meg a Swarmot a Container Orchestration lehetőségként, míg a Google a Kubernetes (más néven K8s) szolgáltatással rendelkezik. Vannak más vezénylők, mint a DC/OS, Mesos, de ebben a dokumentumban beszélünk Swarm és K8s, mivel szélesebb körben használják őket.

A docker-tárolókon is ugyanazok a szemcsés felületek és implementációk futnak, amelyek bárhol Orleans futnak. Az alkalmazás Docker-tárolókban való futtatásához nincs szükség különleges szempontokra.

Az itt tárgyalt fogalmak használhatóak a .NET Core és a .NET 4.6.1 típusú változatokon Orleans is, de a Docker és a .NET Core platformfüggetlen jellegének szemléltetéséhez a .NET Core használatát figyelembe véve a példára fogunk összpontosítani. Ebben a cikkben a platformspecifikus (Windows/Linux/OSX) részletek is megadhatók.

Előfeltételek

Ez a cikk feltételezi, hogy a következő előfeltételek vannak telepítve:

  • Docker – A Docker4X könnyen használható telepítőt biztosít a főbb támogatott platformokhoz. Docker motort és Docker Swarmot is tartalmaz.
  • Kubernetes (K8s) – A Google ajánlata a Container Orchestration-ra. Útmutatást tartalmaz a Minikube (A K8s helyi üzembe helyezése) és a kubectl telepítéséhez, valamint annak minden függőségéhez.
  • .NET – A .NET platformfüggetlen íze
  • Visual Studio Code (VSCode) – Tetszőleges IDE-t használhat. A VSCode platformfüggetlen, ezért arra használjuk, hogy minden platformon működjön. A VSCode telepítése után telepítse a C# bővítményt.

Fontos

Ha nem fogja használni, nem szükséges telepítenie a Kubernetes-t. A Docker4X telepítője már tartalmazza a Swarmot, így nincs szükség további telepítésre a használatához.

Feljegyzés

Windows rendszeren a Docker telepítője engedélyezi a Hyper-V-t a telepítési folyamat során. Mivel ez a cikk és a példák a .NET Core-t használják, a használt tárolólemezképek a Windows Server NanoServeren alapulnak. Ha nem tervezi a .NET Core használatát, és a .NET 4.6.1 teljes keretrendszerét célozza meg, a használt rendszerképnek a Windows Server Core-nak és az 1.4+-os verziónak kell lennie (amely csak a .NET teljes keretrendszerét Orleans támogatja).

Megoldás létrehozása – Orleans

Az alábbi utasítások bemutatják, hogyan hozhat létre normál Orleans megoldást az új dotnet eszközkészlet használatával.

A parancsokat a platformon megfelelő módon módosítsa. A címtárstruktúra is csak javaslat. Kérjük, módosítsa az igényeinek megfelelően.

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

Eddig csak a megoldásstruktúra és a projektek létrehozásához használt sablonkódot használtuk, és referenciákat adtunk a projektek között. Semmi más, mint egy normál Orleans projekt.

Mire ez a cikk meg lett írva, Orleans a 2.0 (amely az egyetlen verzió, amely támogatja a .NET Core-t és a platformfüggetlen verziót) a Technology Preview-ban van, így NuGet-csomagjai myGet-csatornán futnak, és nem jelennek meg Nuget.org hivatalos hírcsatornában. Az előzetes verziójú NuGet-csomagok telepítéséhez parancssori felülettel dotnet kényszerítjük ki a forráscsatornát és a MyGet-verziót:

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

Ok, most már rendelkezik az összes alapvető függőségével egy egyszerű Orleans alkalmazás futtatásához. Vegye figyelembe, hogy eddig semmi sem változott a szokásos Orleans alkalmazástól. Most adjunk hozzá néhány kódot, hogy valamit el tudjunk vele végezni.

Az Orleans alkalmazás implementálása

Tegyük fel, hogy a VSCode-ot használja, a megoldáskönyvtárból futtassa a következőtcode .: . Ez megnyitja a könyvtárat a VSCode-ban, és betölti a megoldást.

Ez a korábban létrehozott megoldásstruktúra.

Visual Studio Code: Explorer, Program.cs kijelölve.

Emellett Program.cs, OrleansHostWrapper.cs, IGreetingGrain.cs és GreetingGrain.cs fájlokat adtunk hozzá az interfészekhez és a szemcsés projektekhez, és az alábbi fájlok kódja található:

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 (ügyfél):

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);
            }
        }
    }
}

Itt nem részletezzük a gabona implementálását, mivel ez a cikk hatókörén kívül esik. Ellenőrizze az ezzel kapcsolatos egyéb dokumentumokat. Ezek a fájlok lényegében egy minimális Orleans alkalmazás, és mi kezdjük belőle, hogy továbblépjen a többi ebben a cikkben.

Ebben a cikkben tagságszolgáltatót használunk OrleansAzureUtils , de bármely más, már Orleanstámogatottat használhat.

A Dockerfile

A tároló létrehozásához a Docker képeket használ. A saját létrehozás módjával kapcsolatos további részletekért tekintse meg a Docker dokumentációját. Ebben a cikkben hivatalos Microsoft-rendszerképeket fogunk használni. A cél- és fejlesztési platformok alapján ki kell választania a megfelelő rendszerképet. Ebben a cikkben egy Linux-alapú rendszerképet használunk microsoft/dotnet:1.1.2-sdk . microsoft/dotnet:1.1.2-sdk-nanoserver Használhatja például a Windowst. Válasszon egyet, amely megfelel az igényeinek.

Megjegyzés a Windows-felhasználók számára: Ahogy korábban említettük, platformfüggetlenként ebben a cikkben a .NET Core és Orleans a Technical Preview 2.0-t használjuk. Ha windowsos Dockert szeretne használni a teljesen kiadott Orleans 1.4+-os verzióval, a Windows Server Core-on alapuló lemezképeket kell használnia, mivel a NanoServer és a Linux-alapú rendszerképek csak a .NET Core-t támogatják.

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

Ez a Dockerfile lényegében letölti és telepíti a VSdbg hibakeresőt, és elindít egy üres tárolót, örökre életben tartja, így nem kell lebontanunk/felszakítani a hibakeresés során.

Éles környezetben a rendszerkép kisebb, mivel csak a .NET Core-futtatókörnyezetet tartalmazza, a teljes SDK-t nem, a dockerfile pedig egy kicsit egyszerűbb:

Dockerfile:

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

A docker-compose fájl

A docker-compose.yml fájl lényegében (egy projekten belül) egy szolgáltatáskészletet és annak függőségeit definiálja szolgáltatási szinten. Minden szolgáltatás egy vagy több példányt tartalmaz egy adott tárolóból, amely a Dockerfile-on kiválasztott rendszerképeken alapul. További részletek a docker-compose docker-compose dokumentációjában találhatók.

Üzembe helyezés esetén Orleans gyakori használati eset, docker-compose.yml ha két szolgáltatást tartalmaz. Az egyik Silónak Orleans , a másik az ügyfélnek Orleans . Az ügyfélnek függősége lenne a silótól, és ez azt jelenti, hogy csak a Silo szolgáltatás üzembe helyezését követően indul el. Egy másik eset egy tároló-/adatbázis-szolgáltatás/tároló hozzáadása, például az SQL Server, amelynek először az ügyfél és a siló előtt kell kezdődnie, így mindkét szolgáltatásnak függőséget kell vállalnia rajta.

Feljegyzés

Mielőtt tovább olvasana, vegye figyelembe, hogy a behúzás a fájlokban docker-compose fontos. Ezért figyeljen rá, ha bármilyen problémája van.

A cikk szolgáltatásaink leírása az alábbiak szerint történik:

docker-compose.override.yml (Hibakeresés):

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 (éles):

version: '3.1'

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

Éles környezetben nem képezzük le a helyi könyvtárat, és a művelet sem.build: Ennek az az oka, hogy éles környezetben a rendszerképeket saját Docker-beállításjegyzékbe kell létrehozni és leküldni.

Mindent összehozni

Most már rendelkezünk az alkalmazás futtatásához Orleans szükséges összes mozgó alkatrészünkkel, össze fogjuk állítani, hogy a megoldást a Dockerben (Végül!) futtathassuk Orleans .

Fontos

A következő parancsokat a megoldáskönyvtárból kell végrehajtani.

Először is győződjön meg arról, hogy minden NuGet-csomagot visszaállítunk a megoldásból. Csak egyszer kell megtennie. Csak akkor kell újra elvégeznie, ha módosítja a projekt csomagfüggőségeit.

dotnet restore

Most hozzuk létre a megoldást a parancssori felülettel dotnet a szokásos módon, és tegyük közzé egy kimeneti könyvtárban:

dotnet publish -o ./bin/PublishOutput

Tipp.

Itt használjuk publish a buildelés helyett, hogy elkerüljük a dinamikusan betöltött szerelvényekkel kapcsolatos problémákat.Orleans Még mindig jobb megoldást keresünk rá.

A létrehozott és közzétett alkalmazással létre kell készítenie a Dockerfile-rendszerképeket. Ezt a lépést projektenként csak egyszer kell végrehajtani, és csak a Docker-fájl, a Docker-compose módosítása vagy a helyi lemezkép-beállításjegyzék bármilyen okból történő törlése esetén szabad újra végrehajtani.

docker-compose build

A rendszer lekérte és gyorsítótárazza a fejlesztési gépen az összes, mindkettőben Dockerfile docker-compose.yml használt rendszerképet. A rendszerképek elkészültek, és mindegyik futtatásra van állítva.

Most futtassuk!

# 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
#

Most, ha futtat egy docker-compose ps, akkor 2 tároló fog futni a orleansdocker projekthez:

# 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

Feljegyzés

Ha Windows rendszeren dolgozik, és a tároló egy Windows rendszerképet használ alapként, a Parancs oszlopban megjelenik a PowerShell relatív parancsa egy tail *NIX-rendszerekhez, így a tároló ugyanúgy fog tartani.

Most, hogy fel vannak állítva a tárolók, nem kell leállítania minden alkalommal, amikor el szeretné indítani az Orleans alkalmazást. Mindössze integrálnia kell az IDE-t az alkalmazás hibakereséséhez a tárolóban, amely korábban a saját tárolójában docker-compose.ymlvolt leképezve.

Méretezés

Miután futtatta a komponálási projektet, egyszerűen fel- vagy leskálázhatja az alkalmazást a parancs használatával docker-compose scale :

# 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

Néhány másodperc elteltével a szolgáltatások a kért példányok adott számára lesznek skálázva.

# 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

Fontos

A Command példák oszlopa csak azért jeleníti meg a tail parancsot, mert a hibakereső tárolót használjuk. Ha éles környezetben lenne, az például jelenne meg dotnet OrleansSilo.dll .

Docker swarm

A Docker-fürtözési verem neve Swarm, további információ: Docker Swarm.

A cikk fürtben Swarm való futtatásához nincs további munkája. Amikor egy Swarm csomóponton futdocker-compose up -d, az a konfigurált szabályok alapján ütemezi a tárolókat. Ugyanez vonatkozik más Swarm-alapú szolgáltatásokra is, például az Azure ACS-re (Swarm módban) és az AWS ECS Container Service-re. Mindössze annyit kell tennie, hogy üzembe helyezi a fürtöt Swarm a dockerizedOrleans alkalmazás üzembe helyezése előtt.

Feljegyzés

Ha olyan Docker-motort használ, amely már támogatja a ( és v3) compose verziótstack, deployakkor a megoldás üzembe helyezésének jobb módja az .docker stack deploy -c docker-compose.yml <name> Ne feledje, hogy a Docker-motor támogatásához v3-írási fájl szükséges, és az olyan üzemeltetett szolgáltatások többsége, mint az Azure és az AWS, továbbra is v2 és régebbi motorokat használ.

Google Kubernetes (K8s)

Ha a Kubernetes-et szeretné üzemeltetniOrleans, a Contrib\Orleans-ben Orleanselérhető egy közösség által fenntartott fürtszolgáltató. Clustering.Kubernetes. Itt dokumentációt és mintákat találhat arról, hogyan üzemeltethet Orleans zökkenőmentesen a Kubernetesben a szolgáltató használatával.

Tárolókon belüli hibakeresés Orleans

Most, hogy már tudja, hogyan futtathat Orleans egy tárolóban az alapoktól kezdve, jó, ha a Docker egyik legfontosabb alapelvét használja. A tárolók nem módosíthatók. És (majdnem) ugyanazzal a képpel, függőségekkel és futtatókörnyezetekkel kell rendelkezniük a fejlesztés során, mint az éles környezetben. Ez biztosítja a jó régi utasítást : "Működik a gépemen!" soha többé nem fordul elő. Ahhoz, hogy ez lehetséges legyen, rendelkeznie kell egy olyan módszerrel, amellyel fejleszthet a tárolón belül , és ebbe beletartozik egy hibakereső csatlakoztatása az alkalmazáshoz a tárolón belül.

Ezt többféleképpen is el lehet érni több eszközzel. Kiértékelése után több, mire írtam ezt a cikket, végül úgy döntöttem, hogy egy úgy néz ki, egyszerűbb, és kevésbé tolakodó az alkalmazásban.

Ahogy a cikk korábbi részében említettük, a mintát a következőképpen fejlesztjük VSCode ki, így az alábbiakban megtudhatja, hogyan csatolhatja a hibakeresőt az Orleans alkalmazáshoz a tárolóban.

Először módosítsa a címtárban lévő .vscode két fájlt a megoldásban:

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

Ez a fájl lényegében azt jelzi VSCode , hogy a projekt létrehozásakor a publish korábban manuálisan végrehajtott parancsot fogja végrehajtani.

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

Most már egyszerűen létrehozhatja a megoldást ( VSCode amely közzé fogja tenni), és elindíthatja a Silót és az ügyfelet is. Egy parancsot docker exec küld a futó docker-compose szolgáltatáspéldánynak/-tárolónak, hogy elindítsa a hibakeresőt az alkalmazásnak, és ennyi. A hibakereső csatlakoztatva van a tárolóhoz, és úgy használja, mintha helyileg futó Orleans alkalmazás lenne. A különbség most az, hogy a tárolón belül van, és ha végzett, egyszerűen közzéteheti a tárolót a beállításjegyzékben, és lekérheti a Docker-gazdagépeken éles környezetben.