在 Kubernetes 环境中部署和运行 Dapr

• 1: Dapr 在 Kubernetes 上的概述
• 2: Kubernetes 集群配置
• 2.1: 设置 Minikube 集群
• 2.2: 设置 KiND 集群
• 2.3: 配置 Azure Kubernetes 服务 (AKS) 集群
• 2.4: 设置 Google Kubernetes Engine (GKE) 集群
• 2.5: 配置弹性Kubernetes服务（EKS）集群
• 3: 在 Kubernetes 集群上部署 Dapr
• 4: 在 Kubernetes 集群上升级 Dapr
• 5: Kubernetes 生产指南
• 6: 使用 Dapr Shared 部署 Dapr 到每个节点或每个集群
• 7: 操作指南：持久化调度器任务
• 8: 部署到混合 Linux/Windows Kubernetes 集群
• 9: 在 Kubernetes Job 中运行 Dapr
• 10: 操作指南：将 Pod 卷挂载到 Dapr sidecar

1 - Dapr 在 Kubernetes 上的概述

Dapr 可以在任何支持的 Kubernetes 版本上运行。为此，Dapr 部署了一些 Kubernetes 服务，这些服务提供了良好的集成，使得在 Kubernetes 上运行 Dapr 应用程序变得简单。

支持的版本

Dapr 对 Kubernetes 的支持遵循 Kubernetes 版本偏差政策。

将 Dapr 部署到 Kubernetes 集群

阅读在 Kubernetes 集群上部署 Dapr以了解如何将 Dapr 部署到您的 Kubernetes 集群。

将 Dapr 添加到 Kubernetes 部署

要在 Kubernetes 集群中部署和运行启用 Dapr 的应用程序，只需在 pod 中添加一些注释即可。例如，在以下示例中，您的 Kubernetes pod 被标注为：

• 为您的服务提供 Dapr 识别的 id 和 port
• 配置追踪功能
• 启动 Dapr sidecar 容器

  annotations:
    dapr.io/enabled: "true"
    dapr.io/app-id: "nodeapp"
    dapr.io/app-port: "3000"
    dapr.io/config: "tracing"

有关更多信息，请查看 Dapr 注释。

从私有注册表拉取容器镜像

Dapr 可以与任何用户应用程序容器镜像无缝配合使用，无论其来源。只需初始化 Dapr并在 Kubernetes 定义中添加 Dapr 注释 以添加 Dapr sidecar。

Dapr 控制平面和 sidecar 镜像来自 daprio Docker Hub 容器注册表，这是一个公共注册表。

有关以下内容的信息：

• 从私有注册表拉取您的应用程序镜像，请参考官方 Kubernetes 文档。
• 使用 Azure 容器注册表与 Azure Kubernetes 服务，请参考 AKS 文档。

教程

通过Hello Kubernetes 教程了解如何在您的 Kubernetes 集群上开始使用 Dapr。

相关链接

• 将 Dapr 部署到 Kubernetes 集群
• 在 Kubernetes 集群上升级 Dapr
• Kubernetes 上 Dapr 的生产指南
• Dapr Kubernetes 快速入门
• 使用 Bridge to Kubernetes 在本地调试 Dapr 应用程序，同时连接到您的 Kubernetes 集群

2 - Kubernetes 集群配置

2.1 - 设置 Minikube 集群

前提条件

• 安装：
  • Docker
  • kubectl
  • Minikube
• 对于 Windows：
  • 在 BIOS 中启用虚拟化
  • 安装 Hyper-V

启动 Minikube 集群

1. 如果您的项目需要，设置默认的虚拟机。

   minikube config set vm-driver [driver_name]
   

2. 启动集群。如果需要，使用 --kubernetes-version 指定 Kubernetes 1.13.x 或更新版本。

   minikube start --cpus=4 --memory=4096
   

3. 启用 Minikube 仪表板和 ingress 插件。

   # 启用仪表板
   minikube addons enable dashboard
   
   # 启用 ingress
   minikube addons enable ingress
   

安装 Helm v3（可选）

如果您使用 Helm，安装 Helm v3 客户端。

故障排除

负载均衡器的外部 IP 地址在 kubectl get svc 中未显示。

在 Minikube 中，kubectl get svc 中的 EXTERNAL-IP 显示为 <pending> 状态。此时，您可以运行 minikube service [service_name] 来打开服务，即使没有外部 IP 地址。

$ kubectl get svc
NAME                        TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)            AGE
...
calculator-front-end        LoadBalancer   10.103.98.37     <pending>     80:30534/TCP       25h
calculator-front-end-dapr   ClusterIP      10.107.128.226   <none>        80/TCP,50001/TCP   25h
...

$ minikube service calculator-front-end
|-----------|----------------------|-------------|---------------------------|
| NAMESPACE |         NAME         | TARGET PORT |            URL            |
|-----------|----------------------|-------------|---------------------------|
| default   | calculator-front-end |             | http://192.168.64.7:30534 |
|-----------|----------------------|-------------|---------------------------|
🎉  正在默认浏览器中打开 Kubernetes 服务 default/calculator-front-end...

相关链接

• 尝试 Dapr 快速入门
• 学习如何在您的集群上 部署 Dapr
• 在 Kubernetes 上升级 Dapr
• Kubernetes 生产指南

2.2 - 设置 KiND 集群

前提条件

• 安装：
  • Docker
  • kubectl
• 对于 Windows：
  • 在 BIOS 中启用虚拟化
  • 安装 Hyper-V

安装和配置 KiND

参考 KiND 文档进行安装。

使用 Docker Desktop 时，请确保您已进行推荐的设置。

配置并创建 KiND 集群

1. 创建一个名为 kind-cluster-config.yaml 的文件，并粘贴以下内容：

   kind: Cluster
   apiVersion: kind.x-k8s.io/v1alpha4
   nodes:
   - role: control-plane
     kubeadmConfigPatches:
     - |
       kind: InitConfiguration
       nodeRegistration:
         kubeletExtraArgs:
           node-labels: "ingress-ready=true"
     extraPortMappings:
     - containerPort: 80
       hostPort: 8081
       protocol: TCP
     - containerPort: 443
       hostPort: 8443
       protocol: TCP
   - role: worker
   - role: worker
   

   此集群配置：

   • 启动一个由控制平面和两个工作节点组成的 Kubernetes 集群。
   • 方便将来设置 Ingress。
   • 将容器端口映射到主机。

2. 运行 kind create cluster 命令，提供集群配置文件：

   kind create cluster --config kind-cluster-config.yaml
   

   预期输出

   Creating cluster "kind" ...
    ✓ Ensuring node image (kindest/node:v1.21.1) 🖼
    ✓ Preparing nodes 📦 📦 📦
    ✓ Writing configuration 📜
    ✓ Starting control-plane 🕹️
    ✓ Installing CNI 🔌
    ✓ Installing StorageClass 💾
    ✓ Joining worker nodes 🚜
   Set kubectl context to "kind-kind"
   You can now use your cluster with:
   
   kubectl cluster-info --context kind-kind
   
   Thanks for using kind! 😊
   

初始化并运行 Dapr

1. 在 Kubernetes 中初始化 Dapr。

   dapr init --kubernetes
   

   Dapr 初始化完成后，您可以在集群上使用其核心组件。

2. 验证 Dapr 组件的状态：

   dapr status -k
   

   预期输出

     NAME                   NAMESPACE    HEALTHY  STATUS   REPLICAS  VERSION  AGE  CREATED
     dapr-sentry            dapr-system  True     Running  1         1.5.1    53s  2021-12-10 09:27.17
     dapr-operator          dapr-system  True     Running  1         1.5.1    53s  2021-12-10 09:27.17
     dapr-sidecar-injector  dapr-system  True     Running  1         1.5.1    53s  2021-12-10 09:27.17
     dapr-dashboard         dapr-system  True     Running  1         0.9.0    53s  2021-12-10 09:27.17
     dapr-placement-server  dapr-system  True     Running  1         1.5.1    52s  2021-12-10 09:27.18
   

3. 将端口转发到 Dapr 仪表板：

   dapr dashboard -k -p 9999
   

4. 访问 http://localhost:9999 检查设置是否成功。

在 Kind Kubernetes 集群上安装 metrics-server

1. 获取 metrics-server 清单

   wget https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
   

2. 向 components.yaml 文件添加不安全的 TLS 参数

   metadata:
      labels:
        k8s-app: metrics-server
    spec:
      containers:
      - args:
        - --cert-dir=/tmp
        - --secure-port=4443
        - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
        - --kubelet-use-node-status-port
        - --kubelet-insecure-tls   <==== 添加此项
        - --metric-resolution=15s
        image: k8s.gcr.io/metrics-server/metrics-server:v0.6.2
        imagePullPolicy: IfNotPresent
        livenessProbe:
          failureThreshold: 3
          httpGet:
            path: /livez
   

3. 应用修改后的清单

   kubectl apply -f components.yaml
   

相关链接

• 尝试 Dapr 快速入门
• 学习如何在您的集群上部署 Dapr
• 在 Kubernetes 上升级 Dapr
• Kubernetes 生产指南

2.3 - 配置 Azure Kubernetes 服务 (AKS) 集群

本指南将引导您安装 Azure Kubernetes 服务 (AKS) 集群。如果您需要更多信息，请参考 快速入门：使用 Azure CLI 部署 AKS 集群

先决条件

• 安装：
  • Docker
  • kubectl
  • Azure CLI

部署 AKS 集群

1. 在终端中登录到 Azure。

   az login
   

2. 设置您的默认订阅：

   az account set -s [your_subscription_id]
   

3. 创建资源组。

   az group create --name [your_resource_group] --location [region]
   

4. 创建 AKS 集群。若需使用特定版本的 Kubernetes，请使用 --kubernetes-version 参数（需 1.13.x 或更高版本）。

   az aks create --resource-group [your_resource_group] --name [your_aks_cluster_name] --node-count 2 --enable-addons http_application_routing --generate-ssh-keys
   

5. 获取 AKS 集群的访问凭据。

   az aks get-credentials -n [your_aks_cluster_name] -g [your_resource_group]
   

AKS Edge Essentials

要使用 Azure Kubernetes 服务 (AKS) Edge Essentials 创建单机 K8s/K3s Linux-only 集群，您可以按照 AKS Edge Essentials 快速入门指南 进行操作。

相关链接

• 了解更多关于 AKS 的 Dapr 扩展
  • 安装 AKS 的 Dapr 扩展
  • 配置 AKS 的 Dapr 扩展
  • 使用 AKS 的 Dapr 扩展部署和运行工作流

2.4 - 设置 Google Kubernetes Engine (GKE) 集群

前提条件

• 安装:
  • kubectl
  • Google Cloud SDK

创建新集群

运行以下命令以创建 GKE 集群：

$ gcloud services enable container.googleapis.com && \
  gcloud container clusters create $CLUSTER_NAME \
  --zone $ZONE \
  --project $PROJECT_ID

更多选项请参阅：

• Google Cloud SDK 文档。
• 通过 Cloud Console 创建集群以获得更具互动性的体验。

私有 GKE 集群的 Sidecar 注入

私有集群的 Sidecar 注入需要额外步骤。

在私有 GKE 集群中，自动创建的主访问防火墙规则未开放 Dapr 所需的 4000 端口用于 Sidecar 注入。

查看相关的防火墙规则：

$ gcloud compute firewall-rules list --filter="name~gke-${CLUSTER_NAME}-[0-9a-z]*-master"

更新现有规则以允许 Kubernetes 主节点访问 4000 端口：

$ gcloud compute firewall-rules update <firewall-rule-name> --allow tcp:10250,tcp:443,tcp:4000

获取 kubectl 的凭据

运行以下命令以获取您的凭据：

$ gcloud container clusters get-credentials $CLUSTER_NAME \
    --zone $ZONE \
    --project $PROJECT_ID

安装 Helm v3（可选）

如果您使用 Helm，请安装 Helm v3 客户端。

故障排除

Kubernetes 仪表板权限

如果您收到类似以下的错误消息：

configmaps is forbidden: User "system:serviceaccount:kube-system:kubernetes-dashboard" cannot list configmaps in the namespace "default"

请执行此命令：

kubectl create clusterrolebinding kubernetes-dashboard -n kube-system --clusterrole=cluster-admin --serviceaccount=kube-system:kubernetes-dashboard

相关链接

• 了解更多关于 GKE 集群的信息
• 尝试 Dapr 快速入门
• 学习如何在您的集群上 部署 Dapr
• 在 Kubernetes 上升级 Dapr
• Kubernetes 生产指南

2.5 - 配置弹性Kubernetes服务（EKS）集群

本指南将引导您配置一个弹性Kubernetes服务（EKS）集群。如果您需要更多信息，请参考创建一个Amazon EKS集群

前提条件

• 需要安装以下工具：
  • kubectl
  • AWS CLI
  • eksctl
  • 一个现有的VPC和子网
  • Dapr CLI

部署一个EKS集群

1. 在终端中配置AWS凭证。

   aws configure
   

2. 创建一个名为cluster-config.yaml的新文件，并将以下内容添加到其中，将[your_cluster_name]、[your_cluster_region]和[your_k8s_version]替换为相应的值：

   apiVersion: eksctl.io/v1alpha5
   kind: ClusterConfig
   
   metadata:
     name: [your_cluster_name]
     region: [your_cluster_region]
     version: [your_k8s_version]
     tags:
       karpenter.sh/discovery: [your_cluster_name]
   
   iam:
     withOIDC: true
   
   managedNodeGroups:
     - name: mng-od-4vcpu-8gb
       desiredCapacity: 2
       minSize: 1
       maxSize: 5
       instanceType: c5.xlarge
       privateNetworking: true
   
   addons:
     - name: vpc-cni 
       attachPolicyARNs:
         - arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy
     - name: coredns
       version: latest 
     - name: kube-proxy
       version: latest
     - name: aws-ebs-csi-driver
       wellKnownPolicies: 
         ebsCSIController: true
   

3. 通过运行以下命令创建集群：

   eksctl create cluster -f cluster.yaml
   

4. 验证kubectl上下文：

   kubectl config current-context
   

为sidecar访问和默认存储类添加Dapr要求：

1. 更新安全组规则，创建端口4000的入站规则，以允许EKS集群与Dapr sidecar通信。

   aws ec2 authorize-security-group-ingress --region [your_aws_region] \
   --group-id [your_security_group] \
   --protocol tcp \
   --port 4000 \
   --source-group [your_security_group]
   

2. 如果没有默认存储类，请添加一个：

kubectl patch storageclass gp2 -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'

安装Dapr

运行以下命令安装Dapr：

dapr init -k

您应该看到以下响应：

⌛  Making the jump to hyperspace...
ℹ️  Note: To install Dapr using Helm, see here: https://docs.dapr.io/getting-started/install-dapr-kubernetes/#install-with-helm-advanced

ℹ️  Container images will be pulled from Docker Hub
✅  Deploying the Dapr control plane with latest version to your cluster...
✅  Deploying the Dapr dashboard with latest version to your cluster...
✅  Success! Dapr has been installed to namespace dapr-system. To verify, run `dapr status -k' in your terminal. To get started, go here: https://docs.dapr.io/getting-started

故障排除

访问权限

如果您遇到访问权限问题，请确保您使用的是创建集群时使用的相同AWS配置文件。如有需要，使用正确的配置文件更新kubectl配置。更多信息请参考这里：

aws eks --region [your_aws_region] update-kubeconfig --name [your_eks_cluster_name] --profile [your_profile_name]

相关链接

• 了解更多关于EKS集群的信息
• 了解更多关于eksctl的信息
• 尝试一个Dapr快速入门
• 了解如何在您的集群上部署Dapr
• Kubernetes生产指南

3 - 在 Kubernetes 集群上部署 Dapr

在 Kubernetes 上设置 Dapr 时，你可以使用 Dapr CLI 或 Helm。

• Dapr CLI
• Helm

dapr init -k --dev

⌛  正在初始化...
ℹ️  注意：要使用 Helm 安装 Dapr，请参见此处：https://docs.dapr.io/getting-started/install-dapr-kubernetes/#install-with-helm-advanced

ℹ️  容器镜像将从 Docker Hub 拉取
✅  正在将最新版本的 Dapr 控制平面部署到集群中...
✅  正在将最新版本的 Dapr 仪表板部署到集群中...
✅  正在将最新版本的 Dapr Redis 部署到集群中...
✅  正在将最新版本的 Dapr Zipkin 部署到集群中...
ℹ️  正在将 "statestore" 组件应用到 Kubernetes "default" 命名空间。
ℹ️  正在将 "pubsub" 组件应用到 Kubernetes "default" 命名空间。
ℹ️  正在将 "appconfig" zipkin 配置应用到 Kubernetes "default" 命名空间。
✅  成功！Dapr 已安装到命名空间 dapr-system。要验证，请在终端中运行 `dapr status -k`。要开始，请访问此处：https://aka.ms/dapr-getting-started

kubectl get pods --namespace default

NAME                              READY   STATUS    RESTARTS   AGE
dapr-dev-zipkin-bfb4b45bb-sttz7   1/1     Running   0          159m
dapr-dev-redis-master-0           1/1     Running   0          159m
dapr-dev-redis-replicas-0         1/1     Running   0          159m
dapr-dev-redis-replicas-1         1/1     Running   0          159m
dapr-dev-redis-replicas-2         1/1     Running   0          158m 

export DAPR_HELM_REPO_URL="https://helm.custom-domain.com/dapr/dapr"
export DAPR_HELM_REPO_USERNAME="username_xxx"
export DAPR_HELM_REPO_PASSWORD="passwd_xxx"

dapr init -k --enable-ha=true

dapr init -k -n mynamespace

dapr init -k --enable-mtls=false

dapr init -k --wait --timeout 600

dapr uninstall -k

helm repo add dapr https://dapr.github.io/helm-charts/
helm repo update
kubectl create namespace dapr-system
# 安装 Dapr 仪表板
helm install dapr-dashboard dapr/dapr-dashboard --namespace dapr-system

kubectl get pods --namespace dapr-system

NAME                                     READY     STATUS    RESTARTS   AGE
dapr-dashboard-7bd6cbf5bf-xglsr          1/1       Running   0          40s
dapr-operator-7bd6cbf5bf-xglsr           1/1       Running   0          40s
dapr-placement-7f8f76778f-6vhl2          1/1       Running   0          40s
dapr-sidecar-injector-8555576b6f-29cqm   1/1       Running   0          40s
dapr-sentry-9435776c7f-8f7yd             1/1       Running   0          40s

helm uninstall dapr --namespace dapr-system

使用基于 Mariner 的镜像

在 Kubernetes 上默认拉取的容器镜像基于 distroless。

或者，你可以使用基于 Mariner 2（最小 distroless）的 Dapr 容器镜像。Mariner，官方称为 CBL-Mariner，是一个由微软维护的免费开源 Linux 发行版和容器基础镜像。对于一些 Dapr 用户，利用基于 Mariner 的容器镜像可以帮助你满足合规要求。

要使用基于 Mariner 的 Dapr 镜像，你需要在 Docker 标签中添加 -mariner。例如，ghcr.io/dapr/dapr:latest 是基于 distroless 的 Docker 镜像，而 ghcr.io/dapr/dapr:latest-mariner 是基于 Mariner 的。也有固定到特定版本的标签可用，例如 1.15-mariner。

• Dapr CLI
• Helm

dapr init -k --image-variant mariner

helm upgrade --install dapr dapr/dapr \
  --version=1.15 \
  --namespace dapr-system \
  --create-namespace \
  --set global.tag=1.15.5-mariner \
  --wait

相关链接

• 使用 Helm 参数和其他细节部署 Dapr
• 在 Kubernetes 上升级 Dapr
• Kubernetes 生产指南
• 配置 state 存储和 pubsub 消息代理

4 - 在 Kubernetes 集群上升级 Dapr

您可以通过 Dapr CLI 或 Helm 来升级 Kubernetes 集群上的 Dapr 控制平面。

• Dapr CLI
• Helm

dapr upgrade -k --runtime-version=1.15.5

❌  升级 Dapr 失败：警告：kubectl apply 应用于由 kubectl create --save-config 或 kubectl apply 创建的资源
CustomResourceDefinition "configurations.dapr.io" 无效：spec.preserveUnknownFields: 无效值：true：必须为 false 以便在模式中使用默认值

升级现有 Dapr 部署以启用高可用模式

通过一些额外步骤在现有 Dapr 部署中启用高可用模式。

相关链接

• Kubernetes 上的 Dapr
• 更多关于使用 Helm 升级 Dapr 的信息
• Dapr 生产指南

5 - Kubernetes 生产指南

集群和容量要求

Dapr 对 Kubernetes 的支持遵循 Kubernetes 版本偏差政策。

以下资源配置可作为起始参考。具体要求会因集群规模、pod 数量及其他因素而有所不同。请根据您的环境进行测试以确定合适的配置值。在生产环境中，建议不要为 Dapr 控制平面组件设置内存限制，以避免出现 OOMKilled pod 状态。

Helm

使用 Helm 安装 Dapr 时，默认未设置限制/请求值。每个组件都有一个 resources 选项（例如，dapr_dashboard.resources），您可以根据需要调整 Dapr 控制平面的资源配置。

Helm chart 说明 提供了详细信息和示例。

对于本地/开发安装，您可以选择不配置 resources 选项。

可选组件

以下 Dapr 控制平面部署是可选的：

• Placement: 用于 Dapr actor
• Sentry: 用于服务到服务调用的 mTLS
• Dashboard: 用于集群的操作视图

Sidecar 资源设置

使用支持的注释设置 Dapr sidecar 的资源分配。与 资源约束 相关的特定注释是：

• dapr.io/sidecar-cpu-limit
• dapr.io/sidecar-memory-limit
• dapr.io/sidecar-cpu-request
• dapr.io/sidecar-memory-request

如果未设置，Dapr sidecar 将在没有资源设置的情况下运行，这可能会导致问题。对于生产就绪的设置，强烈建议配置这些设置。

生产就绪设置中 Dapr sidecar 的示例设置：

上述 CPU 和内存限制考虑了 Dapr 支持大量 I/O 绑定操作。使用 监控工具 获取 sidecar（和应用程序）容器的基线，并根据这些基线调整这些设置。

有关在 Kubernetes 中配置资源的更多详细信息，请参阅以下 Kubernetes 指南：

• 为容器和 Pod 分配内存资源
• 为容器和 Pod 分配 CPU 资源

在 Dapr sidecar 上设置软内存限制

当您设置了内存限制时，建议在 Dapr sidecar 上设置软内存限制。使用软内存限制时，sidecar 垃圾收集器在超过限制时释放内存，而不是等待其达到运行时堆中最后一次存在的内存量的两倍。Go 的 垃圾收集器 默认会等待，这可能导致 OOM Kill 事件。

例如，对于一个内存限制设置为 1000Mi 的应用程序，其 app-id 为 nodeapp，您可以在 pod 注释中使用以下内容：

  annotations:
    dapr.io/enabled: "true"
    dapr.io/app-id: "nodeapp"
    # 我们的 daprd 内存设置
    dapr.io/sidecar-memory-limit: "1000Mi"   # 您的内存限制
    dapr.io/env: "GOMEMLIMIT=900MiB"         # 您内存限制的 90%。还请注意后缀 "MiB" 而不是 "Mi"

在此示例中，软限制设置为 90%，以留出 5-10% 给其他服务，如推荐。

GOMEMLIMIT 环境变量 允许某些内存大小的后缀：B、KiB、MiB、GiB 和 TiB。

高可用模式

在生产就绪配置中部署 Dapr 时，最好以控制平面的高可用 (HA) 配置进行部署。这将在 dapr-system 命名空间中为每个控制平面 pod 创建三个副本，使 Dapr 控制平面能够保留三个运行实例并在单个节点故障和其他中断中幸存。

对于新的 Dapr 部署，可以通过以下两种方式设置 HA 模式：

• Dapr CLI，和
• Helm charts

对于现有的 Dapr 部署，您可以通过几个额外步骤启用 HA 模式。

单个服务 HA Helm 配置

您可以通过将 global.ha.enabled 标志设置为 true 来跨所有服务配置 HA 模式。默认情况下，--set global.ha.enabled=true 完全被尊重且无法覆盖，因此不可能同时将 placement 或调度服务作为单个实例。

注意： 调度和 placement 服务的 HA 不是默认设置。

要独立于 global.ha.enabled 标志将调度和 placement 扩展到三个实例，请将 global.ha.enabled 设置为 false，并将 dapr_scheduler.ha 和 dapr_placement.ha 设置为 true。例如：

helm upgrade --install dapr dapr/dapr \
 --version=1.15 \
 --namespace dapr-system \
 --create-namespace \
 --set global.ha.enabled=false \
 --set dapr_scheduler.ha=true \
 --set dapr_placement.ha=true \
 --wait

为控制平面服务设置集群关键优先级类名称

在某些情况下，节点可能会有内存和/或 CPU 压力，Dapr 控制平面 pod 可能会被选中进行驱逐。为防止这种情况，您可以为 Dapr 控制平面 pod 设置一个关键优先级类名称。这确保了 Dapr 控制平面 pod 不会被驱逐，除非所有其他优先级较低的 pod 都被驱逐。

了解更多关于 保护关键任务 Pod 的信息。

Kubernetes 中有两个内置的关键优先级类：

• system-cluster-critical
• system-node-critical（最高优先级）

建议将 priorityClassName 设置为 system-cluster-critical 用于 Dapr 控制平面 pod。

对于新的 Dapr 控制平面部署，可以通过 helm 值 global.priorityClassName 设置 system-cluster-critical 优先级类模式。

此优先级类可以通过 Dapr CLI 和 Helm charts 设置， 使用 helm --set global.priorityClassName=system-cluster-critical 参数。

Dapr 版本 < 1.14

对于低于 v1.14 的 Dapr 版本，建议您向 Dapr 控制平面命名空间添加 ResourceQuota。这可以防止与调度 pod 相关的问题 集群可能被配置 限制哪些 pod 可以被分配高优先级类。对于 v1.14 及更高版本，Helm chart 会自动添加此项。

如果您在命名空间 dapr-system 中安装了 Dapr，您可以创建一个 ResourceQuota，内容如下：

apiVersion: v1
kind: ResourceQuota
metadata:
  name: dapr-system-critical-quota
  namespace: dapr-system
spec:
  scopeSelector:
    matchExpressions:
      - operator : In
        scopeName: PriorityClass
        values: [system-cluster-critical]

使用 Helm 部署 Dapr

访问使用 Helm 部署 Dapr 的完整指南。

参数文件

建议创建一个 values 文件，而不是在命令中指定参数。将 values 文件检入源代码控制，以便您可以跟踪其更改。

查看可用参数和设置的完整列表。

以下命令在 dapr-system 命名空间中运行每个控制平面服务的三个副本。

# 添加/更新官方 Dapr Helm 仓库。
helm repo add dapr https://dapr.github.io/helm-charts/
# 或添加/更新私有 Dapr Helm 仓库。
helm repo add dapr http://helm.custom-domain.com/dapr/dapr/ \
   --username=xxx --password=xxx
helm repo update

# 查看哪些 chart 版本可用
helm search repo dapr --devel --versions

# 创建一个 values 文件来存储变量
touch values.yml
cat << EOF >> values.yml
global:
  ha:
    enabled: true
EOF

# 运行安装/升级
helm install dapr dapr/dapr \
  --version=<Dapr chart version> \
  --namespace dapr-system \
  --create-namespace \
  --values values.yml \
  --wait

# 验证安装
kubectl get pods --namespace dapr-system

Dapr Helm chart 自动部署具有 kubernetes.io/os=linux 标签的节点的亲和性。您可以将 Dapr 控制平面部署到 Windows 节点。有关更多信息，请参阅 部署到混合 Linux/Windows K8s 集群。

使用 Helm 升级 Dapr

Dapr 支持以下步骤的零停机时间升级。

升级 CLI（推荐）

升级 CLI 是可选的，但推荐。

1. 下载最新版本 的 CLI。
2. 验证 Dapr CLI 是否在您的路径中。

升级控制平面

在 Kubernetes 集群上升级 Dapr。

更新数据平面（sidecars）

更新运行 Dapr 的 pod 以获取 Dapr 运行时的新版本。

1. 对任何具有 dapr.io/enabled 注释的部署发出滚动重启命令：

   kubectl rollout restart deploy/<Application deployment name>
   

2. 通过以下任一方式查看所有启用 Dapr 的部署列表：

   • Dapr Dashboard

   • 使用 Dapr CLI 运行以下命令：

     dapr list -k
     
     APP ID     APP PORT  AGE  CREATED
     nodeapp    3000      16h  2020-07-29 17:16.22
     

在现有 Dapr 部署中启用高可用性

为现有 Dapr 部署启用 HA 模式需要两个步骤：

1. 删除现有的 placement 有状态集。

   kubectl delete statefulset.apps/dapr-placement-server -n dapr-system
   

   您删除 placement 有状态集是因为在 HA 模式下，placement 服务添加了 Raft 用于领导者选举。然而，Kubernetes 仅允许有限的字段在有状态集中进行修补，随后会导致 placement 服务的升级失败。

   删除现有的 placement 有状态集是安全的。代理会重新连接并重新注册到新创建的 placement 服务，该服务在 Raft 中持久化其表。

2. 发出升级命令。

   helm upgrade dapr ./charts/dapr -n dapr-system --set global.ha.enabled=true
   

推荐的安全配置

正确配置时，Dapr 确保安全通信，并可以通过许多内置功能使您的应用程序更安全。

验证您的生产就绪部署包括以下设置：

1. 相互认证 (mTLS) 已启用。Dapr 默认启用 mTLS。了解更多关于如何使用您自己的证书。

2. 应用程序到 Dapr API 认证 已启用。这是您的应用程序与 Dapr sidecar 之间的通信。为了保护 Dapr API 免受未经授权的应用程序访问，启用 Dapr 的基于令牌的认证。

3. Dapr 到应用程序 API 认证 已启用。这是 Dapr 与您的应用程序之间的通信。让 Dapr 知道它正在使用令牌认证与授权应用程序通信。

4. 组件 secret 数据配置在 secret 存储中，而不是硬编码在组件 YAML 文件中。了解如何使用 Dapr 组件的 secret。

5. Dapr 控制平面安装在专用命名空间中，例如 dapr-system。

6. Dapr 支持并启用 为某些应用程序设置组件范围。这不是必需的实践。了解更多关于组件范围。

推荐的 Placement 服务配置

Placement 服务 是 Dapr 中的一个组件，负责通过 placement 表向所有 Dapr sidecar 传播 actor 地址信息（更多信息可以在 这里 找到）。

在生产环境中运行时，建议使用以下值配置 Placement 服务：

1. 高可用性。确保 Placement 服务具有高可用性（三个副本）并能在单个节点故障中幸存。Helm chart 值：dapr_placement.ha=true
2. 内存日志。使用内存 Raft 日志存储以加快写入速度。权衡是更多的 placement 表传播（因此，在最终的 Placement 服务 pod 故障中，网络流量会增加）。Helm chart 值：dapr_placement.cluster.forceInMemoryLog=true
3. 无元数据端点。禁用未认证的 /placement/state 端点，该端点暴露了 Placement 服务的 placement 表信息。Helm chart 值：dapr_placement.metadataEnabled=false
4. 超时 控制 Placement 服务与 sidecar 之间网络连接的敏感性，使用以下超时值。默认值已设置，但您可以根据网络条件调整这些值。
   1. dapr_placement.keepAliveTime 设置 Placement 服务在 gRPC 流上向 Dapr sidecar 发送 keep alive ping 的间隔，以检查连接是否仍然存活。较低的值将在 pod 丢失/重启时导致较短的 actor 重新平衡时间，但在正常操作期间会增加网络流量。接受 1s 到 10s 之间的值。默认值为 2s。
   2. dapr_placement.keepAliveTimeout 设置 Dapr sidecar 响应 Placement 服务的 keep alive ping 的超时时间，然后 Placement 服务关闭连接。较低的值将在 pod 丢失/重启时导致较短的 actor 重新平衡时间，但在正常操作期间会增加网络流量。接受 1s 到 10s 之间的值。默认值为 3s。
   3. dapr_placement.disseminateTimeout 设置在 actor 成员更改（通常与 pod 重启相关）后传播延迟的超时时间，以避免在多个 pod 重启期间过度传播。较高的值将减少传播频率，但会延迟表传播。接受 1s 到 3s 之间的值。默认值为 2s。

服务账户令牌

默认情况下，Kubernetes 在每个容器中挂载一个包含 服务账户令牌 的卷。应用程序可以使用此令牌，其权限因集群和命名空间的配置等因素而异，以对 Kubernetes 控制平面执行 API 调用。

在创建新 Pod（或 Deployment、StatefulSet、Job 等）时，您可以通过在 pod 的 spec 中设置 automountServiceAccountToken: false 来禁用自动挂载服务账户令牌。

建议您考虑在不依赖服务账户令牌的情况下，将应用程序部署为 automountServiceAccountToken: false，以提高 pod 的安全性。例如，您可能需要服务账户令牌，如果：

• 您的应用程序需要与 Kubernetes API 交互。
• 您正在使用与 Kubernetes API 交互的 Dapr 组件；例如，Kubernetes secret 存储 或 Kubernetes 事件绑定。

因此，Dapr 不会自动为您设置 automountServiceAccountToken: false。然而，在您的解决方案不需要服务账户的所有情况下，建议您在 pod 的 spec 中设置此选项。

跟踪和指标配置

Dapr 默认启用跟踪和指标。建议您为您的应用程序和 Dapr 控制平面在生产中设置分布式跟踪和指标。

如果您已经有自己的可观察性设置，您可以禁用 Dapr 的跟踪和指标。

跟踪

为 Dapr 配置跟踪后端。

指标

对于指标，Dapr 在端口 9090 上暴露了一个 Prometheus 端点，可以被 Prometheus 抓取。

设置 Prometheus、Grafana 和其他监控工具与 Dapr。

注入器看门狗

Dapr Operator 服务包括一个 注入器看门狗，可用于检测和修复您的应用程序的 pod 可能在没有 Dapr sidecar（daprd 容器）的情况下部署的情况。例如，它可以帮助在集群完全故障后恢复应用程序。

在 Kubernetes 模式下运行 Dapr 时，注入器看门狗默认禁用。然而，您应该考虑根据您的具体情况启用它并设置适当的值。

请参阅 Dapr operator 服务文档 以获取有关注入器看门狗及其启用方法的更多详细信息。

为 sidecar 容器配置 seccompProfile

默认情况下，Dapr sidecar 注入器注入一个没有任何 seccompProfile 的 sidecar。然而，为了使 Dapr sidecar 容器在具有 受限 配置文件的命名空间中成功运行，sidecar 容器需要 securityContext.seccompProfile.Type 不为 nil。

请参阅 参数和注释概述 以在 sidecar 容器上设置适当的 seccompProfile。

最佳实践

观看此视频，深入了解在 Kubernetes 上运行 Dapr 的最佳实践。

6 - 使用 Dapr Shared 部署 Dapr 到每个节点或每个集群

了解如何使用 Dapr Shared 作为 sidecar 的替代部署方式

Dapr 会自动为您的应用程序注入一个 sidecar，以启用 Dapr API，从而实现最佳的可用性和可靠性。

Dapr Shared 提供了两种替代的部署策略：通过 Kubernetes 的 DaemonSet 实现每节点部署，或通过 Deployment 实现每集群部署。

• DaemonSet: 当以 Kubernetes 的 DaemonSet 资源运行 Dapr Shared 时，daprd 容器会在集群中的每个 Kubernetes 节点上运行。这可以减少应用程序与 Dapr 之间的网络延迟。
• Deployment: 当以 Kubernetes 的 Deployment 运行 Dapr Shared 时，Kubernetes 调度器会决定 daprd 容器实例在集群中的哪个节点上运行。

Dapr Shared 部署

对于您部署的每个 Dapr 应用程序，您需要使用不同的 shared.appId 来部署 Dapr Shared Helm chart。

为什么选择 Dapr Shared？

默认情况下，当 Dapr 安装到 Kubernetes 集群中时，Dapr 控制平面会将 Dapr 作为 sidecar 注入到带有 Dapr 注释（dapr.io/enabled: "true"）的应用程序中。sidecar 提供了许多优势，包括提高弹性，因为每个应用程序都有一个实例，并且应用程序与 sidecar 之间的所有通信都无需经过网络。

虽然 sidecar 是 Dapr 的默认部署方式，但某些用例需要其他方法。假设您希望将工作负载的生命周期与 Dapr API 解耦。一个典型的例子是函数或函数即服务（FaaS）运行时，它可能会自动缩减您的空闲工作负载以释放资源。在这种情况下，可能需要将 Dapr API 和所有 Dapr 异步功能（如订阅）分开。

Dapr Shared 是为这些场景而创建的，扩展了 Dapr sidecar 模型，提供了两种新的部署方法：DaemonSet（每节点）和 Deployment（每集群）。

重要

无论您选择哪种部署方法，重要的是要理解在大多数用例中，每个服务（app-id）都有一个 Dapr Shared 实例（Helm 发布）。这意味着如果您的应用程序由三个微服务组成，建议每个服务都有自己的 Dapr Shared 实例。您可以通过尝试 Hello Kubernetes with Dapr Shared 教程 来看到这一点。

DeamonSet（每节点）

使用 Kubernetes DaemonSet，您可以定义需要在集群中每个节点上部署一次的应用程序。这使得在同一节点上运行的应用程序可以与本地 Dapr API 通信，无论 Kubernetes Scheduler 将您的工作负载调度到哪里。

注意

由于 DaemonSet 在每个节点上安装一个实例，与每集群部署的 Deployment 相比，它在集群中消耗更多资源，但具有提高弹性的优势。

Deployment（每集群）

Kubernetes Deployments 每个集群安装一次。根据可用资源，Kubernetes Scheduler 决定工作负载在哪个节点上调度。对于 Dapr Shared，这意味着您的工作负载和 Dapr 实例可能位于不同的节点上，这可能会引入相当大的网络延迟，但资源使用减少。

开始使用 Dapr Shared

先决条件

在安装 Dapr Shared 之前，请确保您已在集群中安装 Dapr。

如果您想开始使用 Dapr Shared，可以通过安装官方 Helm Chart 创建一个新的 Dapr Shared 实例：

helm install my-shared-instance oci://registry-1.docker.io/daprio/dapr-shared-chart --set shared.appId=<DAPR_APP_ID> --set shared.remoteURL=<REMOTE_URL> --set shared.remotePort=<REMOTE_PORT> --set shared.strategy=deployment

您的 Dapr 启用应用程序现在可以通过将 Dapr SDK 指向或发送请求到 Dapr Shared 实例暴露的 my-shared-instance-dapr Kubernetes 服务来使用 Dapr Shared 实例。

上述 my-shared-instance 是 Helm Chart 发布名称。

如果您使用 Dapr SDK，可以为您的应用程序设置以下环境变量以连接到 Dapr Shared 实例（在此情况下，运行在 default 命名空间中）：

        env:
        - name: DAPR_HTTP_ENDPOINT
          value: http://my-shared-instance-dapr.default.svc.cluster.local:3500
        - name: DAPR_GRPC_ENDPOINT
          value: http://my-shared-instance-dapr.default.svc.cluster.local:50001 

如果您不使用 SDK，可以向这些端点发送 HTTP 或 gRPC 请求。

下一步

• 尝试 Hello Kubernetes with Dapr Shared 教程。
• 在 Dapr Shared 仓库中阅读更多内容。

error running scheduler: etcdserver: mvcc: database space exceeded

dapr init -k --set dapr_scheduler.cluster.storageSize=16Gi --set dapr_scheduler.etcdSpaceQuota=16Gi

helm upgrade --install dapr dapr/dapr \
--version=1.15 \
--namespace dapr-system \
--create-namespace \
--set dapr_scheduler.cluster.storageSize=16Gi \
--set dapr_scheduler.etcdSpaceQuota=16Gi \
--wait

NAMESPACE     NAME                                              STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   VOLUMEATTRIBUTESCLASS   AGE
dapr-system   dapr-scheduler-data-dir-dapr-scheduler-server-0   Bound    pvc-9f699d2e-f347-43b0-aa98-57dcf38229c5   1Gi        RWO            standard       <unset>                 3m25s
dapr-system   dapr-scheduler-data-dir-dapr-scheduler-server-1   Bound    pvc-f4c8be7b-ffbe-407b-954e-7688f2482caa   1Gi        RWO            standard       <unset>                 3m25s
dapr-system   dapr-scheduler-data-dir-dapr-scheduler-server-2   Bound    pvc-eaad5fb1-98e9-42a5-bcc8-d45dba1c4b9f   1Gi        RWO            standard       <unset>                 3m25s

NAME                                       CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                                                         STORAGECLASS   VOLUMEATTRIBUTESCLASS   REASON   AGE
pvc-9f699d2e-f347-43b0-aa98-57dcf38229c5   1Gi        RWO            Delete           Bound    dapr-system/dapr-scheduler-data-dir-dapr-scheduler-server-0   standard       <unset>                          4m24s
pvc-eaad5fb1-98e9-42a5-bcc8-d45dba1c4b9f   1Gi        RWO            Delete           Bound    dapr-system/dapr-scheduler-data-dir-dapr-scheduler-server-2   standard       <unset>                          4m24s
pvc-f4c8be7b-ffbe-407b-954e-7688f2482caa   1Gi        RWO            Delete           Bound    dapr-system/dapr-scheduler-data-dir-dapr-scheduler-server-1   standard       <unset>                          4m24s

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standard
provisioner: my.driver
allowVolumeExpansion: true
...

kubectl delete sts -n dapr-system dapr-scheduler-server --cascade=orphan

kubectl edit pvc -n dapr-system dapr-scheduler-data-dir-dapr-scheduler-server-0 dapr-scheduler-data-dir-dapr-scheduler-server-1 dapr-scheduler-data-dir-dapr-scheduler-server-2

dapr init -k --set dapr_scheduler.cluster.storageClassName=my-storage-class

helm upgrade --install dapr dapr/dapr \
--version=1.15 \
--namespace dapr-system \
--create-namespace \
--set dapr_scheduler.cluster.storageClassName=my-storage-class \
--wait

dapr init -k --set dapr_scheduler.cluster.inMemoryStorage=true

helm upgrade --install dapr dapr/dapr \
--version=1.15 \
--namespace dapr-system \
--create-namespace \
--set dapr_scheduler.cluster.inMemoryStorage=true \
--wait

helm install dapr dapr/dapr --set global.daprControlPlaneOs=windows

kubectl delete -f deploy_linux.yaml
kubectl delete -f deploy_windows.yaml
helm uninstall dapr

apiVersion: batch/v1
kind: Job
metadata:
  name: job-with-shutdown
spec:
  template:
    metadata:
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "with-shutdown"
    spec:
      containers:
      - name: job
        image: alpine
        command: ["/bin/sh", "-c", "apk --no-cache add curl && sleep 20 && curl -X POST localhost:3500/v1.0/shutdown"]
      restartPolicy: Never

package main

import (
	"context"
	"log"
	"os"

	dapr "github.com/dapr/go-sdk/client"
)

func main() {
  client, err := dapr.NewClient()
  if err != nil {
    log.Panic(err)
  }
  defer client.Close()
  defer client.Shutdown()
  // Job
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  namespace: default
  labels:
    app: myapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "myapp"
        dapr.io/app-port: "8000"
        dapr.io/volume-mounts: "my-volume1:/mnt/sample1,my-volume2:/mnt/sample2"
        dapr.io/volume-mounts-rw: "my-volume3:/tmp/sample3"
    spec:
      volumes:
        - name: my-volume1
          hostPath:
            path: /sample
        - name: my-volume2
          persistentVolumeClaim:
            claimName: pv-sample
        - name: my-volume3
          emptyDir: {}
...