Docker dağıtımı
İpucu
Docker veya Orleanshakkında bilgi sahibi olsanız bile, geçici çözümleri olan sorunlardan kaçınmak için bu makaleyi sonuna kadar okumanız önerilir.
Bu makale ve örneği devam eden bir çalışmadır. Herhangi bir geri bildirim, pr veya öneri kabul edilir.
Docker'a çözüm dağıtma Orleans
Orleans Docker orchestrators ve kümeleme yığınlarının tasarlandığı şekilde Docker'a dağıtım yapmak karmaşık olabilir. En karmaşık şey, Docker Swarm ve Kubernetes ağ modelinden Katman Ağı kavramını anlamaktır.
Docker kapsayıcıları ve ağ modelleri çoğunlukla durum bilgisi olmayan ve sabit kapsayıcılar çalıştıracak şekilde tasarlanmıştır. Bu nedenle, node.js veya Nginx uygulamalarını çalıştıran bir kümeyi döndürmek oldukça kolaydır. Ancak, gerçek bir kümelenmiş veya dağıtılmış uygulama (tabanlı uygulamalar gibi Orleans) gibi daha ayrıntılı bir şey kullanmaya çalışırsanız, sonunda ayarlamada sorun yaşıyor olursunuz. Mümkündür, ancak web tabanlı uygulamalar kadar basit değildir.
Docker kümelemeyi, kapsayıcı orchestrator kullanılarak yönetilen tek bir kaynak havuzu olarak çalışmak üzere birden çok ana bilgisayarı bir araya getirmektir. Docker Inc. , Google'da Kubernetes (diğer adıyla K8s) varken Container Orchestration seçeneği olarak Swarm'u sağlar. DC/OS, Mesos gibi başka Orchestrator'lar da vardır, ancak bu belgede daha yaygın olarak kullanıldıkları için Swarm ve K8s hakkında konuşacağız.
Her yerde Orleans çalışan aynı tanecik arabirimler ve uygulama zaten desteklenmektedir Docker kapsayıcılarında da çalıştırılır. Uygulamanızı Docker kapsayıcılarında çalıştırabilmek için dikkat edilmesi gereken özel noktalar yoktur.
Burada açıklanan kavramlar hem .NET Core hem de .NET 4.6.1 çeşitlerinde Orleans kullanılabilir, ancak Docker ve .NET Core'un platformlar arası doğasını göstermek için .NET Core kullandığınızı göz önünde bulundurarak örneğe odaklanacağız. Platforma özgü (Windows/Linux/OSX) ayrıntıları bu makalede sağlanabilir.
Önkoşullar
Bu makalede aşağıdaki önkoşulların yüklü olduğu varsayılır:
- Docker - Docker4X, desteklenen başlıca platformlar için kullanımı kolay bir yükleyiciye sahiptir. Docker altyapısını ve docker Swarm'u içerir.
- Kubernetes (K8s) - Google'ın Container Orchestration teklifi. Tüm bağımlılıklarıyla birlikte Minikube(yerel bir K8s dağıtımı) ve kubectl yükleme yönergeleri içerir.
- .NET - .NET'in platformlar arası tadı
- Visual Studio Code (VSCode) - İstediğiniz IDE'i kullanabilirsiniz. VSCode platformlar arası olduğundan tüm platformlarda çalıştığından emin olmak için bunu kullanıyoruz. VSCode'u yükledikten sonra C# uzantısını yükleyin.
Önemli
Kullanmayacaksanız Kubernetes'i yüklemeniz gerekmez. Docker4X yükleyicisi Swarm'u zaten içerdiği için kullanmak için ek yükleme gerekmez.
Not
Windows'da Docker yükleyicisi, yükleme işleminde Hyper-V'yi etkinleştirir. Bu makalede ve örneklerinde .NET Core kullanıldığından, kullanılan kapsayıcı görüntüleri Windows Server NanoServer'ı temel alır. .NET Core kullanmayı planlamıyorsanız ve .NET 4.6.1 tam çerçevesini hedefleyecekseniz, kullanılan görüntü Windows Server Core ve 1.4+ sürümü olmalıdır (yalnızca .NET tam çerçevesini Orleans destekler).
Orleans çözüm oluştur
Aşağıdaki yönergelerde, yeni dotnet araçları kullanarak normal Orleans bir çözümün nasıl oluşturulacağı gösterilmektedir.
Lütfen komutları platformunuzda uygun olan her şeye uyarlayın. Ayrıca, dizin yapısı yalnızca bir öneridir. Lütfen ihtiyaçlarınıza göre uyarlayın.
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
Şu ana kadar yaptığımız çözüm yapısını ve projelerini oluşturmak ve projeler arasında başvurular eklemek için ortak kod oluşturmaktı. Normal Orleans bir projeden farklı bir şey yoktur.
Bu makale yazıldığında, Orleans 2.0 (.NET Core ve platformlar arası desteği olan tek sürümdür) Technology Preview'dadır, bu nedenle NuGet paketleri MyGet akışında barındırılır ve resmi Nuget.org akışta yayımlanmaz. Önizleme NuGet paketlerini yüklemek için Kaynak akışı ve MyGet sürümünü zorlayan CLI kullanacağız dotnet :
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
Tamam, artık basit Orleans bir uygulamayı çalıştırmak için tüm temel bağımlılıklara sahipsiniz. Şu ana kadar normal Orleans uygulamanızdan hiçbir şeyin değişmediğini unutmayın. Şimdi kodla bir şeyler yapabilmemiz için kod ekleyelim.
Uygulamanızı Orleans uygulama
VSCode kullandığınızı varsayarsak, çözüm dizininden komutunu çalıştırıncode .. Bu işlem, VSCode'da dizini açar ve çözümü yükler.
Bu, daha önce oluşturduğumuz çözüm yapısıdır.
Ayrıca sırasıyla arabirimlere ve tahıl projelerine Program.cs, OrleansHostWrapper.cs, IGreetingGrain.cs ve GreetingGrain.cs dosyaları ekledik ve bu dosyaların kodu aşağıdadır:
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 (Silo):
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 (istemci):
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);
}
}
}
}
Bu makalenin kapsamı dışında olduğundan, burada tahıl uygulamasıyla ilgili ayrıntılara girilmiyor. Lütfen bununla ilgili diğer belgeleri denetleyin. Bu dosyalar temelde minimal Orleans bir uygulamadır ve bu makalenin geri kalanıyla ilerlemek için ondan başlayacağız.
Bu makalede, üyelik sağlayıcısını kullanıyoruz OrleansAzureUtils ancak tarafından Orleanszaten desteklenen diğer herhangi bir sağlayıcıyı kullanabilirsiniz.
The Dockerfile
Kapsayıcınızı oluşturmak için Docker görüntüleri kullanır. Kendi belgenizi oluşturma hakkında daha fazla bilgi için Docker belgelerine bakabilirsiniz. Bu makalede resmi Microsoft görüntülerini kullanacağız. Hedef ve geliştirme platformlarına bağlı olarak uygun görüntüyü seçmeniz gerekir. Bu makalede, Linux tabanlı bir görüntü olan öğesini kullanıyoruz microsoft/dotnet:1.1.2-sdk . Örneğin Windows için kullanabilirsiniz microsoft/dotnet:1.1.2-sdk-nanoserver . İhtiyaçlarınıza uygun bir tane seçin.
Windows kullanıcıları için not: Daha önce belirtildiği gibi, platformlar arası olmak için bu makalede .NET Core ve Orleans Technical preview 2.0 kullanıyoruz. Docker'ı Windows'ta tam olarak yayımlanan Orleans 1.4+ ile kullanmak istiyorsanız, NanoServer ve Linux tabanlı görüntülerden bu yana Windows Server Core'a dayalı görüntüleri kullanmanız gerekir, yalnızca .NET Core'ı destekler.
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"]
Bu Dockerfile temelde VSdbg hata ayıklayıcısını indirip yükler ve boş bir kapsayıcı başlatır ve bu kapsayıcıyı sonsuza kadar canlı tutarak hata ayıklarken yok etmemize/kaldırmamıza gerek kalmaz.
Artık üretim için görüntü, SDK'nın tamamını değil yalnızca .NET Core çalışma zamanını içerdiğinden ve dockerfile biraz daha basit olduğundan daha küçüktür:
Dockerfile:
FROM microsoft/dotnet:1.1.2-runtime
WORKDIR /app
ENTRYPOINT ["dotnet", "OrleansSilo.dll"]
COPY . /app
Docker-compose dosyası
docker-compose.yml Dosyası temelde bir hizmet kümesini ve hizmet düzeyinde bağımlılıklarını tanımlar (bir proje içinde). Her hizmet, Dockerfile dosyanızda seçtiğiniz görüntüleri temel alan belirli bir kapsayıcının bir veya daha fazla örneğini içerir. ile ilgili docker-compose diğer ayrıntılar docker-compose belgelerinde bulunabilir.
Orleans Bir dağıtım için yaygın bir kullanım örneği, iki hizmet içeren bir'e docker-compose.yml sahip olmaktır. Biri Silo için Orleans , diğeri de İstemci için Orleans . İstemcinin Silo'ya bağımlılığı olacaktır ve bu da yalnızca Silo hizmeti çalışmaya başladıktan sonra başlayacağı anlamına gelir. Başka bir durum, örneğin SQL Server gibi bir depolama/veritabanı hizmeti/kapsayıcısı eklemektir. Bu, istemciden ve silodan önce başlamalıdır, bu nedenle her iki hizmet de buna bağımlılık almalıdır.
Not
Daha fazla bilgi okumadan önce, girintilemenin dosyalarda docker-compose önemli olduğunu lütfen unutmayın. Bu nedenle, herhangi bir sorununuz varsa buna dikkat edin.
Bu makale için hizmetlerimizi şu şekilde açıklayacağız:
docker-compose.override.yml (Hata Ayıklama):
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 (üretim):
version: '3.1'
services:
orleans-client:
image: orleans-client
depends_on:
- orleans-silo
orleans-silo:
image: orleans-silo
Üretimde yerel dizini eşlemiyoruz ve eylem de yok build: . Bunun nedeni, üretim ortamında görüntülerin derlenmesi ve kendi Docker Kayıt Defterinize gönderilmesidir.
Her şeyi bir araya getirin
Artık Uygulamanızı çalıştırmak Orleans için gereken tüm hareketli parçalara sahibiz, çözümümüzü Orleans Docker içinde çalıştırabilmek için bunu bir araya getireceğiz (Son olarak!).
Önemli
Aşağıdaki komutlar çözüm dizininden gerçekleştirilmelidir.
İlk olarak, çözümümüzden tüm NuGet paketlerini geri yüklediğimizden emin olalım. Bunu yalnızca bir kez yapmanız yeterlidir. Yalnızca projenizde herhangi bir paket bağımlılığını değiştirirseniz bunu yeniden yapmanız gerekir.
dotnet restore
Şimdi her zamanki gibi CLI kullanarak dotnet çözümümüzü derleyelim ve bunu bir çıkış dizininde yayımlayalım:
dotnet publish -o ./bin/PublishOutput
İpucu
'de Orleansdinamik olarak yüklenen derlemelerimizle ilgili sorunları önlemek için derleme yerine burada kullanıyoruzpublish. Bunun için hala daha iyi bir çözüm arıyoruz.
Uygulama derlenip yayımlandıktan sonra Dockerfile görüntülerinizi oluşturmanız gerekir. Bu adımın proje başına yalnızca bir kez gerçekleştirilmesi gerekir ve yalnızca Dockerfile, docker-compose veya herhangi bir nedenle yerel görüntü kayıt defterinizi temizlediyseniz yeniden gerçekleştirilmelidir.
docker-compose build
Hem hem de Dockerfile docker-compose.yml içinde kullanılan tüm görüntüler kayıt defterinden alınır ve geliştirme makinenizde önbelleğe alınır. Resimleriniz derlenir ve çalışmaya hazırsınız.
Şimdi çalıştıralım!
# 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
#
Şimdi bir docker-compose psçalıştırırsanız, proje için orleansdocker çalışan 2 kapsayıcı görürsünüz:
# 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
Not
Windows kullanıyorsanız ve kapsayıcınız temel olarak bir Windows görüntüsü kullanıyorsa, Command sütunu size *NIX sistemlerinde powershell göreli komutunu tail gösterir, böylece kapsayıcı aynı şekilde devam eder.
Artık kapsayıcılarınızı kullanıma açtığınıza göre, uygulamanızı her başlatmak istediğinizde bunu durdurmanız Orleans gerekmez. Tek ihtiyacınız olan IDE'nizi tümleştirerek kapsayıcının içinde daha önce kendi içinde eşlenmiş olan uygulamanın hatalarını ayıklamaktır docker-compose.yml.
Ölçeklendirme
Oluşturma projenizi çalıştırdıktan sonra, komutunu kullanarak docker-compose scale uygulamanızın ölçeğini kolayca artırabilir veya azaltabilirsiniz:
# 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
Birkaç saniye sonra hizmetlerin istediğiniz örnek sayısına göre ölçeklendirildiğini görürsünüz.
# 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
Önemli
Bu Command örneklerde yer alan sütun, hata ayıklayıcı kapsayıcısını tail kullandığımız için komutu gösteriyor. Üretimde olsaydık, örneğin gösteriliyor dotnet OrleansSilo.dll olurdu.
Docker swarm
Docker kümeleme yığını Swarm olarak adlandırılır. Daha fazla bilgi için bkz. Docker Swarm.
Bu makaleyi kümede Swarm çalıştırmak için ek bir işiniz yoktur. Bir Swarm düğümde çalıştırdığınızdadocker-compose up -d, kapsayıcılar yapılandırılan kurallara göre zamanlanır. Aynı durum Azure ACS (Swarm modunda) ve AWS ECS Container Service gibi diğer Swarm tabanlı hizmetler için de geçerlidir. Tek yapmanız gereken dockerizedOrleans uygulamanızı dağıtmadan Swarm önce kümenizi dağıtmaktır.
Not
, ve v3 desteğine sahip Swarm modunda bir Docker altyapısı kullanıyorsanız, çözümünüzü dağıtmak için stackdeploydaha iyi bir yaklaşımdırdocker stack deploy -c docker-compose.yml <name>.compose Docker altyapınızı desteklemek için v3 oluşturma dosyası gerektirdiğini ve Azure ve AWS gibi barındırılan hizmetlerin çoğunluğunun v2 ve eski altyapıları kullanmaya devam ettiğini unutmayın.
Google Kubernetes (K8s)
barındırmak Orleansiçin Kubernetes kullanmayı planlıyorsanız OrleansContrib\Orleans konumunda topluluk tarafından korunan bir kümeleme sağlayıcısı mevcuttur. Clustering.Kubernetes. Burada, sağlayıcıyı kullanarak Kubernetes'te sorunsuz bir şekilde barındırma Orleans hakkında belgeler ve örnekler bulabilirsiniz.
Kapsayıcıların içinde hata ayıklama Orleans
Artık bir kapsayıcıda sıfırdan çalıştırmayı Orleans bildiğinize göre, Docker'daki en önemli ilkelerden birini kullanmak iyi bir seçenektir. Kapsayıcılar sabittir. Ayrıca geliştirme aşamasındaki görüntü, bağımlılıklar ve çalışma zamanının üretimdekiyle neredeyse aynı olması gerekir. Bu, "Makinemde çalışıyor!" eski deyimini güvence altına alıyor. bir daha asla olmaz. Bunu mümkün kılmak için kapsayıcının içinde geliştirmenin bir yolunun olması ve kapsayıcının içinde uygulamanıza bir hata ayıklayıcının eklenmesi gerekir.
Bunu birden çok araç kullanarak yapmanın birden çok yolu vardır. Birkaçını değerlendirdikten sonra, bu makaleyi yazdığımda, daha basit görünen ve uygulamaya daha az müdahale eden birini seçtim.
Bu makalede daha önce belirtildiği gibi, örneği geliştirmek için kullanıyoruz VSCode , bu nedenle kapsayıcının içinde Uygulamanıza Orleans eklenen hata ayıklayıcıyı nasıl edinebileceğimiz aşağıda verilmiştir.
İlk olarak, çözümünüzdeki dizininizin .vscode içindeki iki dosyayı değiştirin:
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"
}
]
}
Bu dosya temelde projeyi her oluşturduğunuzda, daha önce el ile yaptığımız gibi komutunu yürüteceğini publish bildirirVSCode.
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"
]
}
}
]
}
Artık çözümü VSCode (yayımlanacak) sürümünden derleyebilir ve hem Silo'yu hem de İstemci'yi başlatabilirsiniz. Uygulamanın hata ayıklayıcısını başlatmak için çalışan docker-compose hizmet örneğine/kapsayıcısına bir docker exec komut gönderir ve bu kadar. Kapsayıcıya ekli hata ayıklayıcınız var ve yerel olarak çalışan Orleans bir uygulamaymış gibi kullanın. Şimdi fark kapsayıcının içinde olmasıdır ve işlemi tamamladıktan sonra kapsayıcıyı kayıt defterinizde yayımlayabilir ve üretimdeki Docker konaklarınıza çekebilirsiniz.
