Hostování Kubernetes

Kubernetes je oblíbenou volbou pro hostování Orleans aplikací. Orleans běží v Kubernetes bez konkrétní konfigurace; může však také využít další znalosti, které poskytuje hostitelská platforma.

Balíček Microsoft.Orleans.Hosting.Kubernetes přidává integraci pro hostování aplikace Orleans v clusteru Kubernetes. Balíček poskytuje rozšiřující metodu, UseKubernetesHosting, která provádí následující akce:

Mějte na paměti, že hostitelský balíček Kubernetes nepoužívá Kubernetes pro clustering. Stále je potřeba samostatný poskytovatel clusteringu. Další informace o konfiguraci clusteringu najdete v dokumentaci ke konfiguraci Serveru.

Nasazení do Kubernetes pomocí .NET Aspire

.NET Aspire zjednodušuje nasazení Kubernetes automatickým generováním manifestů Kubernetes z vaší konfigurace AppHost. Místo ručního zápisu souborů Aspire YAML může vytvořit potřebné prostředky nasazení, služby a konfigurace na základě grafu závislostí vaší aplikace.

Přidejte integraci pro hostování Kubernetes

Nejprve nainstalujte balíček NuGet Aspire.Hosting.Kubernetes v projektu AppHost:

dotnet add package Aspire.Hosting.Kubernetes

Pak do hostitele AppHost přidejte prostředí Kubernetes:

var builder = DistributedApplication.CreateBuilder(args);

// Add the Kubernetes environment
var k8s = builder.AddKubernetesEnvironment("k8s");

// Add your Orleans silo project
var silo = builder.AddProject<Projects.MySilo>("silo");

builder.Build().Run();

Volitelně můžete přizpůsobit vlastnosti prostředí Kubernetes:

builder.AddKubernetesEnvironment("k8s")
    .WithProperties(k8s =>
    {
        k8s.HelmChartName = "my-orleans-app";
    });

Generování manifestů Kubernetes

Pomocí příkazového řádku Aspire vygenerujte manifesty Kubernetes pro Váš projekt Aspire.

aspire publish -o ./k8s-manifests

Tím se vygeneruje úplná sada souborů YAML Kubernetes v zadaném výstupním adresáři, včetně:

  • Nasazení nebo stavové sady pro každou službu v AppHostu
  • Služby pro připojení k síti
  • Objekty ConfigMap a tajné kódy pro konfiguraci
  • Charty Helm pro snadnější správu nasazení
  • PersistentVolumes a PersistentVolumeClaims pro prostředky úložiště

Nasazení do clusteru

Po vygenerování manifestů je nasaďte pomocí kubectl nebo nástroje Helm.

# Using kubectl
kubectl apply -f ./k8s-manifests

# Or using Helm (if Helm charts were generated)
helm install my-orleans-app ./k8s-manifests/charts/my-orleans-app

AspireVýhody vygenerovaných manifestů

  • Konzistentní konfigurace: Proměnné prostředí, porty a odkazy na prostředky se automaticky synchronizují.
  • Správa závislostí: Služby jsou nakonfigurované se správnými připojovacími řetězci a odkazy na služby.
  • Orleans-aware: Integrace Orleans hostování zajišťuje, aby byla zahrnuta správná konfigurace sila.
  • Podpora Helmu: Vygenerované grafy Helm umožňují parametrizovaná nasazení napříč prostředími.

Návod

V případě produkčních nasazení zkontrolujte a podle potřeby upravte vygenerované manifesty. Ke konfiguraci hodnot specifických pro prostředí použijte externí parametry .

Podrobné informace o Aspire integraci Kubernetes najdete v Aspire dokumentaci k integraci Kubernetes.

Další informace o konfiguraci Orleans s .NET Aspire najdete v tématu .NET AspireOrleans integrace.

Ruční konfigurace Kubernetes

Tato funkce vynucuje některé požadavky na nasazení služby:

  • Názvy sila musí odpovídat názvům podů.
  • Pody musí mít orleans/serviceId a orleans/clusterId štítky odpovídající štítkům sila ServiceId a ClusterId. Metoda UseKubernetesHosting propaguje tyto popisky do odpovídajících možností Orleans z proměnných prostředí.
  • Pody musí mít nastavené následující proměnné prostředí: POD_NAME, POD_NAMESPACE, POD_IP, ORLEANS_SERVICE_ID, ORLEANS_CLUSTER_ID.

Následující příklad ukazuje, jak správně nakonfigurovat tyto štítky a proměnné prostředí:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dictionary-app
  labels:
    orleans/serviceId: dictionary-app
spec:
  selector:
    matchLabels:
      orleans/serviceId: dictionary-app
  replicas: 3
  template:
    metadata:
      labels:
        # This label identifies the service to Orleans
        orleans/serviceId: dictionary-app

        # This label identifies an instance of a cluster to Orleans.
        # Typically, this is the same value as the previous label, or any
        # fixed value.
        # In cases where you don't use rolling deployments (for example,
        # blue/green deployments),
        # this value can allow for distinct clusters that don't communicate
        # directly with each other,
        # but still share the same storage and other resources.
        orleans/clusterId: dictionary-app
    spec:
      containers:
        - name: main
          image: my-registry.azurecr.io/my-image
          imagePullPolicy: Always
          ports:
          # Define the ports Orleans uses
          - containerPort: 11111
          - containerPort: 30000
          env:
          # The Azure Storage connection string for clustering is injected as an
          # environment variable.
          # You must create it separately using a command such as:
          # > kubectl create secret generic az-storage-acct `
          #     --from-file=key=./az-storage-acct.txt
          - name: STORAGE_CONNECTION_STRING
            valueFrom:
              secretKeyRef:
                name: az-storage-acct
                key: key
          # Configure settings to let Orleans know which cluster it belongs to
          # and which pod it's running in.
          - name: ORLEANS_SERVICE_ID
            valueFrom:
              fieldRef:
                fieldPath: metadata.labels['orleans/serviceId']
          - name: ORLEANS_CLUSTER_ID
            valueFrom:
              fieldRef:
                fieldPath: metadata.labels['orleans/clusterId']
          - name: POD_NAMESPACE
            valueFrom:
              fieldRef:
                fieldPath: metadata.namespace
          - name: POD_NAME
            valueFrom:
              fieldRef:
                fieldPath: metadata.name
          - name: POD_IP
            valueFrom:
              fieldRef:
                fieldPath: status.podIP
          - name: DOTNET_SHUTDOWNTIMEOUTSECONDS
            value: "120"
          request:
            # Set resource requests
      terminationGracePeriodSeconds: 180
      imagePullSecrets:
        - name: my-image-pull-secret
  minReadySeconds: 60
  strategy:
    rollingUpdate:
      maxUnavailable: 0
      maxSurge: 1

U clusterů s podporou RBAC může být také nutné udělit požadovaný přístup k účtu služby Kubernetes pro pody:

kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: orleans-hosting
rules:
- apiGroups: [ "" ]
  resources: ["pods"]
  verbs: ["get", "watch", "list", "delete", "patch"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: orleans-hosting-binding
subjects:
- kind: ServiceAccount
  name: default
  apiGroup: ''
roleRef:
  kind: Role
  name: orleans-hosting
  apiGroup: ''

Sondy životaschopnosti, připravenosti a zaváděcí

Kubernetes dokáže testovat pody a určit stav služby. Další informace najdete v tématu Konfigurace sond životaschopnosti, připravenosti a spuštění v dokumentaci Kubernetes.

Orleans používá protokol členství clusteru k okamžitému zjištění selhání procesu nebo sítě a jejich obnovení. Každý uzel monitoruje podmnožinu jiných uzlů a odesílá pravidelné sondy. Pokud uzel nereaguje na několik po sobě jdoucích sond z více dalších uzlů, cluster ho vynuceně odebere. Jakmile se uzel, který selhal, dozví o jeho odebrání, okamžitě se ukončí. Kubernetes restartuje ukončený proces, který se pak pokusí znovu připojit ke clusteru.

Sondy Kubernetes pomáhají určit, jestli se proces v podu spouští a není zablokovaný v zombie stavu. Tyto sondy neověřují připojení mezi pody ani rychlost odezvy ani neprovádějí kontroly funkčnosti na úrovni aplikace. Pokud pod nereaguje na liveness probe, Kubernetes může tento pod nakonec ukončit a přeplánovat. Sondy Kubernetes a Orleans sondy se proto doplňují.

Doporučeným přístupem je konfigurace sond zjištění dostupnosti v Kubernetes, které provádějí výhradně místní jednoduchou kontrolu, zda aplikace běží dle očekávání. Tyto sondy slouží k ukončení procesu, pokud dojde například k úplnému zablokování, například kvůli chybě za běhu nebo jiné nepravděpodobné události.

Kvóty prostředků

Kubernetes spolupracuje s operačním systémem na implementaci kvót prostředků. To umožňuje vynucovat rezervace procesoru a paměti nebo limity. Pro primární aplikaci, která obsluhuje interaktivní zatížení, se implementace omezujících limitů nedoporučuje, pokud není potřeba. Je důležité si uvědomit, že požadavky a limity se podstatně liší ve smyslu a umístění implementace. Než nastavíte požadavky nebo limity, potřebujete čas, abyste získali podrobné informace o tom, jak se implementují a vynucují. Paměť se například nemusí měřit jednotně mezi Kubernetes, jádrem Linuxu a monitorovacím systémem. Kvóty procesoru se nemusí vynucovat podle očekávání.

Řešení problémů

Pody havarují a hlásí chybu KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT must be defined

Úplná zpráva o výjimce:

Unhandled exception. k8s.Exceptions.KubeConfigException: unable to load in-cluster configuration, KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT must be defined
at k8s.KubernetesClientConfiguration.InClusterConfig()
  • Zkontrolujte, zda jsou proměnné prostředí KUBERNETES_SERVICE_HOST a KUBERNETES_SERVICE_PORT nastaveny uvnitř podu. Zkontrolujte spuštěním příkazu kubectl exec -it <pod_name> /bin/bash -c env.
  • Ujistěte se, že automountServiceAccountToken je nastaveno na true v Kubernetes deployment.yaml. Další informace najdete v tématu Nastavení účtů služeb pro pody.
  • Last updated on