Dapr 的部署方式

• 1: 在本地自托管模式下运行 Dapr
• 1.1: Dapr 自托管模式概述
• 1.2: 如何使用 Podman 在自托管模式下运行 Dapr
• 1.3: 如何使用 Docker 自托管 Dapr
• 1.4: 操作指南：在离线或隔离环境中运行Dapr
• 1.5: 如何在没有 Docker 的环境中以自托管模式运行 Dapr
• 1.6: 操作指南：持久化调度器作业
• 1.7: 在自托管环境中升级 Dapr 的步骤
• 1.8: 在自托管环境中卸载 Dapr
• 2: 在 Kubernetes 环境中部署和运行 Dapr
• 2.1: Dapr 在 Kubernetes 上的概述
• 2.2: Kubernetes 集群配置
• 2.2.1: 设置 Minikube 集群
• 2.2.2: 设置 KiND 集群
• 2.2.3: 配置 Azure Kubernetes 服务 (AKS) 集群
• 2.2.4: 设置 Google Kubernetes Engine (GKE) 集群
• 2.2.5: 配置弹性Kubernetes服务（EKS）集群
• 2.3: 在 Kubernetes 集群上部署 Dapr
• 2.4: 在 Kubernetes 集群上升级 Dapr
• 2.5: Kubernetes 生产指南
• 2.6: 使用 Dapr Shared 部署 Dapr 到每个节点或每个集群
• 2.7: 操作指南：持久化调度器任务
• 2.8: 部署到混合 Linux/Windows Kubernetes 集群
• 2.9: 在 Kubernetes Job 中运行 Dapr
• 2.10: 操作指南：将 Pod 卷挂载到 Dapr sidecar
• 3: 在无服务器服务中运行 Dapr
• 3.1: Azure 容器应用

1 - 在本地自托管模式下运行 Dapr

1.1 - Dapr 自托管模式概述

概述

Dapr 可以配置为在本地开发者机器或生产环境的虚拟机上运行自托管模式。每个服务都会有一个 Dapr 运行时进程（或称为 sidecar），该进程配置为使用状态存储、发布/订阅、绑定组件和其他构建块。

初始化

Dapr 可以通过 Docker（默认）或 slim-init 模式进行初始化。它也可以在 离线或隔离环境中初始化和运行。

默认的 Docker 设置提供了即用的功能，包含以下容器和配置：

• 一个 Redis 容器，配置为同时用于状态管理和发布/订阅的默认组件。
• 一个 Zipkin 容器，用于诊断和跟踪。
• 默认的 Dapr 配置和组件安装在 $HOME/.dapr/ (Mac/Linux) 或 %USERPROFILE%\.dapr\ (Windows)。

dapr-placement 服务负责管理 actor 的分布方案和键范围设置。此服务不作为容器启动，仅在您使用 Dapr actor 时才需要。有关 actor Placement 服务的更多信息，请阅读 actor 概述。

使用 Dapr 启动应用程序

您可以使用 dapr run CLI 命令 启动 Dapr sidecar 进程和您的应用程序。其他参数和标志可以在这里找到。

名称解析

Dapr 使用 名称解析组件 在 服务调用 构建块中进行服务发现。默认情况下，Dapr 在自托管模式下使用 mDNS。

如果您在虚拟机上运行 Dapr 或 mDNS 不可用的情况下，可以使用 HashiCorp Consul 组件进行名称解析。

1.2 - 如何使用 Podman 在自托管模式下运行 Dapr

本文介绍了如何在 Windows/Linux/macOS 机器或虚拟机上使用 Podman 运行 Dapr。

准备工作

• Dapr CLI
• Podman

设置 Dapr 环境

要设置 Dapr 控制平面容器并创建默认配置文件，请执行以下命令：

dapr init --container-runtime podman

以进程方式运行应用程序和 sidecar

可以使用 dapr run CLI 命令 启动 Dapr sidecar 和您的应用程序：

dapr run --app-id myapp --app-port 5000 -- dotnet run

此命令会启动 daprd sidecar 和您的应用程序。

以进程方式运行应用程序，sidecar 作为 Docker 容器运行

如果您希望在 Docker 容器中运行 Dapr，而应用程序在主机上以进程方式运行，则需要配置 Podman 使用主机网络，以便 Dapr 和应用程序可以共享 localhost 网络接口。

在 Linux 主机上运行 Podman 时，可以使用以下命令启动 Dapr：

podman run --network="host" --mount type=bind,source="$(pwd)"/components,target=/components daprio/daprd:edge ./daprd -app-id <my-app-id> -app-port <my-app-port>

然后，您可以在主机上运行您的应用程序，它们可以通过 localhost 网络接口进行连接。

卸载 Dapr 环境

要卸载 Dapr，请运行：

dapr uninstall --container-runtime podman --all

1.3 - 如何使用 Docker 自托管 Dapr

本文介绍如何在 Windows/Linux/macOS 机器或虚拟机上使用 Docker 运行 Dapr。

前提条件

• Dapr CLI
• Docker
• Docker-Compose（可选）

设置 Dapr 环境

运行以下命令以初始化 Dapr 控制平面并创建默认配置文件：

dapr init

以进程形式运行应用和 sidecar

使用 dapr run CLI 命令 启动 Dapr sidecar 和您的应用程序：

dapr run --app-id myapp --app-port 5000 -- dotnet run

此命令将启动 daprd sidecar 并运行 dotnet run，从而启动您的应用程序。

应用以进程形式运行，sidecar 以 Docker 容器形式运行

如果您希望在 Docker 容器中运行 Dapr，而应用程序在主机上以进程形式运行，则需要配置 Docker 使用主机网络，以便 Dapr 和应用程序可以共享 localhost 网络接口。

在 Linux 主机上运行 Docker 守护进程时，可以使用以下命令启动 Dapr：

docker run --net="host" --mount type=bind,source="$(pwd)"/components,target=/components daprio/daprd:edge ./daprd -app-id <my-app-id> -app-port <my-app-port>

然后，您可以在主机上运行您的应用程序，它们应通过 localhost 网络接口进行连接。

在单个 Docker 容器中运行应用和 Dapr

仅用于开发目的

不建议在同一个容器中同时运行 Dapr 运行时和应用程序。然而，在本地开发场景中可以这样做。

为此，您需要编写一个 Dockerfile 来安装 Dapr 运行时、Dapr CLI 和您的应用程序代码。然后您可以使用 Dapr CLI 调用 Dapr 运行时和您的应用程序代码。

下面是一个实现此目的的 Dockerfile 示例：

FROM python:3.7.1
# 安装 dapr CLI
RUN wget -q https://raw.githubusercontent.com/dapr/cli/master/install/install.sh -O - | /bin/bash

# 安装 daprd
ARG DAPR_BUILD_DIR
COPY $DAPR_BUILD_DIR /opt/dapr
ENV PATH="/opt/dapr/:${PATH}"
RUN dapr init --slim

# 安装您的应用
WORKDIR /app
COPY python .
RUN pip install requests
ENTRYPOINT ["dapr"]
CMD ["run", "--app-id", "nodeapp", "--app-port", "3000", "node", "app.js"]

请记住，如果 Dapr 需要与其他组件通信，例如 Redis，这些也需要对其可访问。

在 Docker 网络上运行

如果您有多个 Dapr 实例在 Docker 容器中运行，并希望它们能够相互通信（例如用于服务调用），那么您需要创建一个共享的 Docker 网络，并确保这些 Dapr 容器连接到该网络。

您可以使用以下命令创建一个简单的 Docker 网络：

docker network create my-dapr-network

在运行您的 Docker 容器时，您可以使用以下命令将它们连接到网络：

docker run --net=my-dapr-network ...

每个容器将在该网络上接收一个唯一的 IP，并能够与该网络上的其他容器通信。

使用 Docker-Compose 运行

Docker Compose 可用于定义多容器应用程序配置。如果您希望在本地运行多个带有 Dapr sidecar 的应用程序而不使用 Kubernetes，建议使用 Docker Compose 定义（docker-compose.yml）。

Docker Compose 的语法和工具超出了本文的范围，建议您参考官方 Docker 文档以获取更多详细信息。

为了使用 Dapr 和 Docker Compose 运行您的应用程序，您需要在 docker-compose.yml 中定义 sidecar 模式。例如：

version: '3'
services:
  nodeapp:
    build: ./node
    ports:
      - "50001:50001" # Dapr 实例通过 gRPC 通信，因此我们需要暴露 gRPC 端口
    depends_on:
      - redis
      - placement
    networks:
      - hello-dapr
  nodeapp-dapr:
    image: "daprio/daprd:edge"
    command: [
      "./daprd",
     "--app-id", "nodeapp",
     "--app-port", "3000",
     "--placement-host-address", "placement:50006", # Dapr 的 placement 服务可以通过 docker DNS 条目访问
     "--resources-path", "./components"
     ]
    volumes:
        - "./components/:/components" # 挂载我们的组件文件夹供运行时使用。挂载位置必须与 --resources-path 参数匹配。
    depends_on:
      - nodeapp
    network_mode: "service:nodeapp" # 将 nodeapp-dapr 服务附加到 nodeapp 网络命名空间

  ... # 部署其他 daprized 服务和组件（例如 Redis）

  placement:
    image: "daprio/dapr"
    command: ["./placement", "--port", "50006"]
    ports:
      - "50006:50006"

  scheduler:
    image: "daprio/dapr"
    command: ["./scheduler", "--port", "50007"]
    ports:
      - "50007:50007"
    # 警告 - 这是一个 tmpfs 卷，您的状态不会在重启后持久化
    volumes:
    - type: tmpfs
      target: /data
      tmpfs:
        size: "10000"
  
  networks:
    hello-dapr: null

对于在 Linux 主机上运行 Docker 守护进程的用户，您还可以使用 network_mode: host 来利用主机网络（如果需要）。

要进一步了解如何使用 Docker Compose 运行 Dapr，请参阅 Docker-Compose 示例。

上述示例还包括一个使用非持久性数据存储进行测试和开发目的的调度器定义。

在 Kubernetes 上运行

如果您的部署目标是 Kubernetes，请使用 Dapr 的一流集成。请参阅 Dapr 在 Kubernetes 上的文档。

名称解析

Dapr 默认使用 mDNS 作为自托管模式下的名称解析组件进行服务调用。如果您在虚拟机上运行 Dapr 或 mDNS 不可用的地方运行 Dapr，则可以使用 HashiCorp Consul 组件进行名称解析。

Docker 镜像

Dapr 提供了多个不同组件的预构建 Docker 镜像，您应选择适合您所需二进制文件、架构和标签/版本的相关镜像。

镜像

在 Docker Hub 上提供了每个 Dapr 组件的已发布 Docker 镜像。

• daprio/dapr（包含所有 Dapr 二进制文件）
• daprio/daprd
• daprio/placement
• daprio/sentry
• daprio/dapr-dev

标签

Linux/amd64

• latest: 最新发布版本，仅用于开发目的。
• edge: 最新的 edge 构建（master）。
• major.minor.patch: 发布版本。
• major.minor.patch-rc.iteration: 发布候选版本。

Linux/arm/v7

• latest-arm: ARM 的最新发布版本，仅用于开发目的。
• edge-arm: ARM 的最新 edge 构建（master）。
• major.minor.patch-arm: ARM 的发布版本。
• major.minor.patch-rc.iteration-arm: ARM 的发布候选版本。

1.4 - 操作指南：在离线或隔离环境中运行Dapr

概述

通常情况下，Dapr初始化时会从网络下载二进制文件并拉取镜像来设置开发环境。然而，Dapr也支持使用预先下载的安装包进行离线或隔离安装，这可以通过Docker或精简模式来实现。每个Dapr版本的安装包都被构建成一个Dapr安装包，可以下载。通过使用这个安装包和Dapr CLI的init命令，你可以在没有网络访问的环境中安装Dapr。

设置

在进行隔离初始化之前，需要预先下载一个Dapr安装包，其中包含CLI、运行时和仪表板的内容。这避免了在本地初始化Dapr时需要下载二进制文件和Docker镜像。

1. 下载特定版本的Dapr安装包。例如，daprbundle_linux_amd64.tar.gz，daprbundle_windows_amd64.zip。

2. 解压缩安装包。

3. 要安装Dapr CLI，将daprbundle/dapr (Windows为dapr.exe)二进制文件复制到合适的位置：

   • 对于Linux/MacOS - /usr/local/bin
   • 对于Windows，创建一个目录并将其添加到系统PATH。例如，创建一个名为c:\dapr的目录，并通过编辑系统环境变量将此目录添加到路径中。

   注意：如果Dapr CLI没有移动到合适的位置，你可以直接使用包中的本地dapr CLI二进制文件。上述步骤是为了将其移动到常用位置并添加到路径中。

初始化Dapr环境

Dapr可以在有或没有Docker容器的隔离环境中初始化。

使用Docker初始化Dapr

（前提条件：环境中可用Docker）

进入安装包目录并运行以下命令：

dapr init --from-dir .

对于Linux用户，如果你使用sudo运行Docker命令，你需要使用“sudo dapr init”

如果你不是在安装包目录下运行上述命令，请提供安装包目录的完整路径。例如，假设安装包目录路径是$HOME/daprbundle，运行dapr init --from-dir $HOME/daprbundle以获得相同的效果。

输出应类似于以下内容：

  正在进行超空间跳跃...
ℹ️  正在安装最新的运行时版本
↘  正在提取二进制文件并设置组件... 已加载镜像：daprio/dapr:$version
✅  提取二进制文件并设置组件完成。
✅  二进制文件提取和组件设置已完成。
ℹ️  daprd二进制文件已安装到$HOME/.dapr/bin。
ℹ️  dapr_placement容器正在运行。
ℹ️  使用`docker ps`检查正在运行的容器。
✅  成功！Dapr已启动并运行。要开始使用，请访问：https://aka.ms/dapr-getting-started

注意：要模拟在线 Dapr初始化，使用dapr init，你也可以运行Redis和Zipkin容器，如下所示：

1. docker run --name "dapr_zipkin" --restart always -d -p 9411:9411 openzipkin/zipkin
2. docker run --name "dapr_redis" --restart always -d -p 6379:6379 redislabs/rejson

不使用Docker初始化Dapr

或者，为了让CLI不安装任何默认配置文件或运行任何Docker容器，可以使用init命令的--slim标志。这样只会安装Dapr的二进制文件。

dapr init --slim --from-dir .

输出应类似于以下内容：

⌛  正在进行超空间跳跃...
ℹ️  正在安装最新的运行时版本
↙  正在提取二进制文件并设置组件... 
✅  提取二进制文件并设置组件完成。
✅  二进制文件提取和组件设置已完成。
ℹ️  daprd二进制文件已安装到$HOME/.dapr/bin。
ℹ️  placement二进制文件已安装到$HOME/.dapr/bin。
✅  成功！Dapr已启动并运行。要开始使用，请访问：https://aka.ms/dapr-getting-started

1.5 - 如何在没有 Docker 的环境中以自托管模式运行 Dapr

前提条件

• 安装 Dapr CLI

初始化无容器的 Dapr

Dapr CLI 提供了一个选项，可以使用 slim init 初始化 Dapr，而无需依赖 Docker 来创建默认的开发环境。安装 Dapr CLI 后，使用以下命令进行 slim init 初始化：

dapr init --slim

这将安装两个不同的二进制文件：

• daprd
• placement

placement 二进制文件用于在 Dapr 自托管安装中启用 actor。

在 slim init 模式下，不会安装用于状态管理或消息发布/订阅的默认组件（如 Redis）。这意味着，除了 服务调用 外，安装时没有其他内置功能可用。您可以根据需要设置自己的环境和自定义组件。

如果配置了状态存储，则可以进行基于 actor 的服务调用，具体说明请参见以下章节。

执行服务调用

请参阅 Hello Dapr slim 示例，了解如何在 slim init 模式下执行服务调用。

启用状态管理或消息发布/订阅

请参阅 在无 Docker 的自托管模式下配置 Redis 的文档，以启用本地状态存储或用于消息传递的发布/订阅代理。

启用 actor

要启用 actor placement：

• 在本地运行 placement 服务。
• 启用支持 ETags 的 事务性状态存储 以使用 actor。例如，在自托管模式下配置的 Redis。

默认情况下，placement 二进制文件安装在：

• 对于 Linux/MacOS: /$HOME/.dapr/bin
• 对于 Windows: %USERPROFILE%\.dapr\bin

• Linux/MacOS
• Windows

$ $HOME/.dapr/bin/placement

INFO[0000] starting Dapr Placement Service -- version 1.0.0-rc.1 -- commit 13ae49d  instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.placement type=log ver=1.0.0-rc.1
INFO[0000] log level set to: info                        instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.placement type=log ver=1.0.0-rc.1
INFO[0000] metrics server started on :9090/              instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.metrics type=log ver=1.0.0-rc.1
INFO[0000] Raft server is starting on 127.0.0.1:8201...  instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.placement.raft type=log ver=1.0.0-rc.1
INFO[0000] placement service started on port 50005       instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.placement type=log ver=1.0.0-rc.1
INFO[0000] Healthz server is listening on :8080          instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.placement type=log ver=1.0.0-rc.1
INFO[0001] cluster leadership acquired                   instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.placement type=log ver=1.0.0-rc.1
INFO[0001] leader is established.                        instance=Nicoletaz-L10.redmond.corp.microsoft.com scope=dapr.placement type=log ver=1.0.0-rc.1

%USERPROFILE%/.dapr/bin/placement.exe -port 6050

time="2022-10-17T14:56:55.4055836-05:00" level=info msg="starting Dapr Placement Service -- version 1.9.0 -- commit fdce5f1f1b76012291c888113169aee845f25ef8" instance=LAPTOP-OMK50S19 scope=dapr.placement type=log ver=1.9.0
time="2022-10-17T14:56:55.4066226-05:00" level=info msg="log level set to: info" instance=LAPTOP-OMK50S19 scope=dapr.placement type=log ver=1.9.0
time="2022-10-17T14:56:55.4067306-05:00" level=info msg="metrics server started on :9090/" instance=LAPTOP-OMK50S19 scope=dapr.metrics type=log ver=1.9.0
time="2022-10-17T14:56:55.4077529-05:00" level=info msg="Raft server is starting on 127.0.0.1:8201..." instance=LAPTOP-OMK50S19 scope=dapr.placement.raft type=log ver=1.9.0
time="2022-10-17T14:56:55.4077529-05:00" level=info msg="placement service started on port 6050" instance=LAPTOP-OMK50S19 scope=dapr.placement type=log ver=1.9.0
time="2022-10-17T14:56:55.4082772-05:00" level=info msg="Healthz server is listening on :8080" instance=LAPTOP-OMK50S19 scope=dapr.placement type=log ver=1.9.0
time="2022-10-17T14:56:56.8232286-05:00" level=info msg="cluster leadership acquired" instance=LAPTOP-OMK50S19 scope=dapr.placement type=log ver=1.9.0
time="2022-10-17T14:56:56.8232286-05:00" level=info msg="leader is established." instance=LAPTOP-OMK50S19 scope=dapr.placement type=log ver=1.9.0

现在，要运行启用了 actor 的应用程序，您可以参考以下示例：

• java-sdk
• python-sdk
• dotnet-sdk

更新状态存储配置文件以匹配您的 Redis 主机和密码设置。

通过将元数据部分设置为类似于 示例 Java Redis 组件 的定义，将其启用为 actor 状态存储。

  - name: actorStateStore
    value: "true"

清理

完成后，请按照 在自托管环境中卸载 Dapr 的步骤移除二进制文件。

下一步

• 使用默认的 Docker 或在 airgap 环境 中运行 Dapr
• 在自托管模式下升级 Dapr

1.6 - 操作指南：持久化调度器作业

调度器服务负责将作业写入嵌入式数据库并进行调度执行。 默认情况下，调度器服务会将数据写入本地卷dapr_scheduler，这意味着数据在重启时会被持久化。

此本地卷的主机文件位置通常位于/var/lib/docker/volumes/dapr_scheduler/_data或~/.local/share/containers/storage/volumes/dapr_scheduler/_data，具体取决于您的容器运行时。 请注意，如果您使用的是Docker Desktop，此卷位于Docker Desktop虚拟机的文件系统中，可以通过以下命令访问：

docker run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh

调度器的持久卷可以通过使用预先存在的自定义卷进行修改，或者由Dapr自动创建。

dapr init --scheduler-volume my-scheduler-volume

1.7 - 在自托管环境中升级 Dapr 的步骤

1. 卸载当前的 Dapr 部署：

   注意

   这将删除默认的 $HOME/.dapr 目录、二进制文件和所有容器（dapr_redis、dapr_placement 和 dapr_zipkin）。如果在 Linux 上运行 docker 命令需要使用 sudo，请使用 sudo。

   dapr uninstall --all
   

2. 访问本指南以下载并安装最新版本的 CLI。

3. 初始化 Dapr 运行时：

   dapr init
   

4. 确认您正在使用最新版本的 Dapr (v1.15.5)：

   $ dapr --version
   
   CLI version: 1.15
   Runtime version: 1.15
   

1.8 - 在自托管环境中卸载 Dapr

以下 CLI 命令用于移除 Dapr sidecar 二进制文件和 placement 容器：

dapr uninstall

上述命令不会移除在 dapr init 时默认安装的 Redis 或 Zipkin 容器，以防您将它们用于其他用途。要移除 Redis、Zipkin、actor placement 容器，以及位于 $HOME/.dapr 或 %USERPROFILE%\.dapr\ 的默认 Dapr 目录，请运行以下命令：

dapr uninstall --all

2 - 在 Kubernetes 环境中部署和运行 Dapr

2.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.2 - Kubernetes 集群配置

2.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.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.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.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.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生产指南

2.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 消息代理

2.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 生产指南

2.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 的最佳实践。

2.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: {}
...

3.1 - Azure 容器应用

了解如何在 Azure 容器应用无服务器平台上运行您的 Dapr 应用程序

Azure 容器应用 是一种无服务器应用托管服务，用户无需管理底层的虚拟机、编排器或其他云基础设施。Azure 容器应用允许您运行打包在多个容器中的应用程序代码，并且对所使用的运行时或编程模型没有特定要求。

Dapr 已集成到容器应用中，您可以直接使用 Dapr API 的功能模块，而无需手动部署 Dapr 运行时。您只需将服务与其 Dapr 组件一起部署即可。

了解更多

教程

访问 Azure 文档 以尝试微服务教程，您将在其中将两个启用 Dapr 的应用程序部署到 Azure 容器应用。

在容器应用上试用 Dapr