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

Docker üzembe helyezése

Tipp.

Még ha ismeri is a Dockert vagy Orleans, ajánlott a cikket a végéig elolvasni, így elkerülheti az ismert kerülő megoldásokkal kapcsolatos lehetséges problémákat.

Ez a cikk és a minta egy folyamatban lévő munka. Visszajelzéseket, PRS-eket vagy javaslatokat szívesen fogadunk.

Megoldások üzembe helyezése Orleans a Dockerben

A Docker környezetbe való üzembe helyezés kihívást jelenthet a Docker orchestratorok és a klaszterezési stackek kialakítása miatt. A legbonyolultabb rész a Docker Swarm átfedési hálózatának és a Kubernetes-hálózatmodellnek a megértése.

A Docker-tárolók és a hálózati modellek elsősorban állapot nélküli és nem módosítható tárolók futtatására lettek kialakítva. A Node.js vagy Nginx-alkalmazásokat futtató fürtök létrehozása meglehetősen egyszerű. Ha azonban valami összetettebbet használ, mint például egy valóban fürtözött vagy elosztott alkalmazás (például az, amelyik az Orleans alapján készült), az beállítási nehézségeket okozhat. Lehetséges, de nem olyan egyszerű, mint a webes alkalmazások üzembe helyezése.

A Docker fürtözés magában foglalja több gazdagép csoportosítását, hogy egyetlen erőforráskészletként funkcionáljon, amelyet egy tárolóvezénylő irányít. Docker Inc. lehetőséget kínál a Swarm számára, míg a Googlea Kubernetes-et (más néven K8-at) kínálja. Léteznek más vezénylők, például a DC/OS és a Mesos , de ez a dokumentum a Swarmra és a K8-ra összpontosít, mivel szélesebb körben használják őket.

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

Az itt tárgyalt fogalmak a .NET Core és a .NET Framework 4.6.1 verziójára Orleansis érvényesek. A Docker és a .NET Core platformfüggetlen jellegének szemléltetéséhez azonban a .NET Core-t használó példákra összpontosítanak. Szükség esetén a platformspecifikus részletek (Windows/Linux/macOS) 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. Tartalmazza a Docker motort és a Docker Swarmot.
  • Kubernetes (K8s): A Google tárolóvezénylési ajánlata. Útmutatást tartalmaz a Minikube (helyi K8s-környezet) és a kubectl és a függőségek telepítéséhez.
  • .NET: A .NET platformfüggetlen változata.
  • Visual Studio Code (VSCode):: Bármely előnyben részesített IDE használható. A VSCode azért használatos itt, mert platformfüggetlen, így a példák minden platformon működnek. A VSCode telepítése után telepítse a C# bővítményt.

Fontos

A Kubernetes telepítése nem szükséges, ha nem használja. A Docker4X telepítője már tartalmazza a Swarmot, így nincs szükség további telepítésre a Swarmhoz.

Feljegyzés

Windows rendszeren a Docker-telepítő engedélyezi a Hyper-V a telepítés 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 inkább a .NET-keretrendszer 4.6.1-es verzióját tervezi használni, használjon olyan rendszerképeket, amelyek a Windows Server Core és a 1.4+ verzióra épülnek (amelyek csak a .NET-keretrendszert támogatják).

Orleans Megoldás létrehozása

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

A parancsokat a platformnak megfelelően alakítsa át. A címtárstruktúra csak javaslat; szükség szerint adaptálják.

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 sablonkódja lett létrehozva, és referenciák lettek hozzáadva közöttük. Ez nem különbözik a normál Orleans projekt beállításától.

A cikk írásakor a Orleans 2.0 (amely támogatja a .NET Core-t és a platformfüggetlen fejlesztést) technológiai előnézet volt. NuGet-csomagjai egy MyGet feeden voltak tárolva, nem a hivatalos NuGet.org feeden. Az előzetes verziójú NuGet-csomagok telepítéséhez használja a dotnet parancssori felületet, és állítsa be a forráscsatornát és a verziót a MyGetből.

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

Rendben, az egyszerű Orleans alkalmazások futtatásához használt összes alapvető függőség már érvényben van. Vegye figyelembe, hogy eddig a pontig semmi sem változott a normál Orleans alkalmazásbeállításról. Most adjunk hozzá néhány kódot, hogy működőképes legyen.

Az Orleans alkalmazás implementálása

Ha a VSCode-ot használja, futtassa code . a megoldáskönyvtárból. Ez a parancs 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.

Program.cs, OrleansHostWrapper.cs, IGreetingGrain.cs és GreetingGrain.cs fájlokat is hozzáadtak az interfészekhez és a szemcsés projektekhez. A fájlok kódja a következő:

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

A szemcsés megvalósítás részleteit itt nem ismertetjük, mivel ez a cikk hatókörén kívül esik. További információért tekintse meg a többi vonatkozó dokumentumot. Ezek a fájlok egy minimális Orleans alkalmazást képviselnek, amely a cikk további részeinek kiindulópontjaként szolgál.

Ez a cikk a tagságszolgáltatót OrleansAzureUtils használja, de bármely más Orleanstámogatott szolgáltató használható.

A Dockerfile

A Docker lemezképeket használ tárolók létrehozásához. Az egyéni rendszerképek létrehozásával kapcsolatos további részletekért tekintse meg a Docker dokumentációját. Ez a cikk hivatalos Microsoft-rendszerképeket használ. A cél- és fejlesztési platformok alapján válassza ki a megfelelő képet. microsoft/dotnet:1.1.2-sdk egy Linux-alapú képfájlt használunk. Windows microsoft/dotnet:1.1.2-sdk-nanoserver esetén például használható. Válassza ki az igényeinek megfelelőt.

Megjegyzés a Windows-felhasználók számára: A platformfüggetlen kompatibilitás fenntartásához ebben a cikkben a .NET Core és Orleans a Technical Preview 2.0 használható. Ha Windowsos Dockert szeretne használni a végleges Orleans 1.4+-os verzióval, használja a Windows Server Core alapú képfájlokat, mivel a NanoServer és a Linux-alapú képfájlok 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, határozatlan ideig életben tartja, így a hibakeresés során nem kell lebontani és újból felhozni.

Gyártásban a képfájl kisebb, mert csak a .NET Core futtatókörnyezetet tartalmazza, nem a teljes SDK-t. A Dockerfile egyszerűbb is.

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 szolgáltatásszinten definiálja a szolgáltatások és függőségeik egy projekten belüli készletét. Minden szolgáltatás egy adott tároló egy vagy több példányát tartalmazza a Dockerfile-ban kiválasztott rendszerképek alapján. További információt docker-compose a docker-compose dokumentációjában talál.

A Orleans telepítés során egy gyakori használati eset egy docker-compose.yml fájlt tartalmaz két szolgáltatással: az egyik a Orleans Silóhoz, a másik az Orleans Ügyfélhez. Az ügyfélszolgáltatás a silószolgáltatástól függ, ami azt jelenti, hogy csak a silószolgáltatás futtatása után indul el. Egy másik forgatókönyv lehet egy tároló vagy adatbázis-szolgáltatás/tároló (például SQL Server) hozzáadása, amelynek az ügyfél és a siló előtt kell kezdődnie. Ebben az esetben az ügyfél- és a silószolgáltatások is az adatbázis-szolgáltatástól függenek.

Feljegyzés

Mielőtt tovább olvasana, vegye figyelembe, hogy a behúzása fájlokban docker-compose fontos. Ügyeljen rá, ha problémák merülnek fel.

A cikk szolgáltatásainak leírása a következő:

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

A termelés során a helyi könyvtár nincs leképezve, és a build: művelet sincs befoglalva. Ennek az az oka, hogy éles környezetben a rendszerképeket el kell készíteni és fel kell tölteni egy privát Docker-repozitóriumba.

Mindent összehozni

Most, hogy minden szükséges összetevő készen áll, állítsuk össze őket a Orleans megoldás Dockeren belüli futtatásához.

Fontos

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

Először ellenőrizze, hogy a megoldás összes NuGet-csomagja helyreállításra került. Ezt általában csak egyszer kell elvégezni, hacsak a csomagfüggőségek nem változnak.

dotnet restore

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

dotnet publish -o ./bin/PublishOutput

Tipp.

publish használatos itt a build helyett, hogy elkerülje a dinamikusan betöltött szerelvényekkel kapcsolatos problémákat a Orleans-ben. Még mindig jobb megoldást keresnek.

Miután az alkalmazás felépült és közzé lett téve, hozza létre a Docker képeket a Dockerfile-ok segítségével. Ennek a lépésnek általában projektenként csak egyszer kell végrehajtania. Csak akkor szükséges újra, ha a Dockerfile vagy a Docker-compose fájl megváltozik, vagy ha a helyi lemezkép-beállításjegyzék bármilyen okból törlődik.

docker-compose build

Mindkét alapkép, amelyet Dockerfile és docker-compose.yml használ, a regisztrációs adatbázisból van lekérve, és gyorsítótárazva van a fejlesztői gépen. Az alkalmazásrendszerképek elkészültek, és minden készen áll a futtatásra.

Most futtassuk az alkalmazást!

# 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 a futtatás docker-compose ps két, a projekthez futó tárolót jelenít meg orleansdocker :

# 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 a Windows rendszeren fut, és a tároló egy windowsos alaprendszerképet használ, a Parancs oszlopban látható a PowerShell-nek megfelelő parancs, amelyet a *NIX rendszereken használnának, így a tároló hasonló módon marad futásban.

Most, hogy a tárolók futnak, nem szükséges leállítani őket minden alkalommal, amikor az Orleans alkalmazásnak el kell indulnia. Egyszerűen integrálja az IDE-t az alkalmazás hibakereséséhez a tárolóban, amely korábban már be lett térképezve docker-compose.yml.

Méretezés

A megírási projekt futtatása után egyszerűen skálázhatja fel vagy le az alkalmazást a docker-compose scale paranccsal:

# 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 számú példányra skálázódnak.

# 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(z) Command oszlop ezekben a példákban azért mutatja a tail parancsot, mert a hibakereső tárolót használják. Például a futó rendszeren így jelenne meg: dotnet OrleansSilo.dll.

Docker Swarm

A Docker fürtözési verem neve a Swarm. További információ: Docker Swarm.

A cikkben ismertetett alkalmazás futtatásához a Swarm fürtben nincs szükség további munkára. docker-compose up -d futtatása a Swarm csomóponton a konfigurált szabályok alapján ütemezi a tárolókat. Ugyanez vonatkozik más Swarm-alapú szolgáltatásokra is, mint például az Azure Kubernetes Service (AKS) (Swarm módban) és az AWS Elastic Container Service (ECS) szolgáltatásra. Csak telepítse a Swarm klasztert a dockerizáltOrleans alkalmazás üzembe helyezése előtt.

Feljegyzés

Ha egy Docker-motort használ, amely támogatja stacka Swarm módot , deployés compose a v3-at, a megoldás üzembe helyezésének jobb módja az .docker stack deploy -c docker-compose.yml <name> Ne feledje, hogy ehhez a Docker-motorral kompatibilis v3-fájl szükséges. Számos üzemeltetett szolgáltatás, például az Azure és az AWS továbbra is v2 és régebbi motorokat használ.

Google Kubernetes (K8s)

Ha a Kubernetes használatát tervezi Orleans hostolásra, a közösség által fenntartott fürtszolgáltató elérhető az OrleansContrib\Orleans.Clustering.Kubernetes oldalon. Itt találja a dokumentációt és mintákat arról, hogyan üzemeltetheti zökkenőmentesen a Orleans a Kubernetesben a szolgáltató segítségével.

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

Most, hogy az alapoktól kezdve már értjük, hogyan futtassunk Orleans egy tárolóban, érdemes kihasználni a Docker egyik legfontosabb alapelvét: a változatlanságot. A tárolóknak (majdnem) ugyanazzal a lemezképpel, függőségekkel és futtatókörnyezetekkel kell rendelkezniük a fejlesztés során, mint az éles környezetben. Ez a gyakorlat segít megelőzni a klasszikus "Működik a gépemen!" problémát. Ennek lehetővé tétele érdekében a tárolón belüli fejlesztésre van szükség, beleértve egy hibakereső csatlakoztatását a benne futó alkalmazáshoz.

Ezt többféleképpen is elérheti különböző eszközökkel. Az íráskor több lehetőség kiértékelése után az alkalmazás számára egyszerűbbnek és kevésbé tolakodónak tűnőt választottuk.

Ahogy korábban említettük, VSCode a minta fejlesztésére szolgál. Így csatolhatja a hibakeresőt az Orleans alkalmazáshoz a tárolón belül:

Először módosítsa a megoldás könyvtárában lévő .vscode két fájlt:

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 amikor a projekt buildel, végrehajtja a publish parancsot, hasonlóan ahhoz, ahogyan azt korábban manuálisan hajtották végre.

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 állítsa össze a megoldást VSCode (amely szintén közzéteszi), és kezdje el mind a Silo, mind az Ügyfél konfigurációkat. A VSCode egy parancsot docker exec küld a futó docker-compose szolgáltatáspéldánynak/-tárolónak az alkalmazáshoz csatolt hibakereső elindításához. Ennyi az egész! A hibakereső a tárolóhoz van csatolva, és ugyanúgy használható, mint egy helyileg futó Orleans alkalmazás hibakeresése. A fő különbség az, hogy az alkalmazás a tárolón belül fut. A fejlesztés befejezése után tegye közzé a tárolórendszerképet a beállításjegyzékben, és húzza le a Docker-gazdagépekre éles környezetben.