diff --git a/DEVELOPER_DOCS/maintainers.yaml b/DEVELOPER_DOCS/maintainers.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9e2291f3ec4b7c21a97ca0b540286424daf1a848
--- /dev/null
+++ b/DEVELOPER_DOCS/maintainers.yaml
@@ -0,0 +1,24 @@
+# 指定所有 maintainers
+maintainers:
+  - default_group:
+      - openanolis_id: xx
+        gitee_id: xxxx
+  - network_group: &network_group
+      - openanolis_id: zhangsan
+        gitee_id: zhangsan
+      - openanolis_id: xxx
+        gitee_id: xxx
+  - io_group: &io_group
+      - openanolis_id: lisi
+        gitee_id: lisi
+      - openanolis_id: xxx
+        gitee_id: xxx
+  - other_group:
+      - openanolis_id: xx
+        gitee_id: xxxx
+# 指定文档目录对应的用户组
+paths:
+  - *: *default_group
+  - ./network/*: *network_group
+  - path2: *io_group
+  - path3: *other_group
\ No newline at end of file
diff --git a/DEVELOPER_DOCS/menu.yaml b/DEVELOPER_DOCS/menu.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..74a2565ae121e50004e6df4f0caa724340318208
--- /dev/null
+++ b/DEVELOPER_DOCS/menu.yaml
@@ -0,0 +1,10 @@
+DEVELOPER_DOCS:
+  menu: menu.yml
+  maintainers: maintainers.yml
+  海光安全虚拟化技术CSV:
+    CSV机密容器-0.1.0:
+      虚拟机中使用机密容器: ../海光安全虚拟化技术CSV/CSV机密容器-0.1.0/在kata CSV虚拟机中使用机密容器.md
+      使用机密容器: ../海光安全虚拟化技术CSV/CSV机密容器-0.1.0/基于 runtime attestation 使用机密容器.md
+    CSV机密容器-0.5.0:
+      Anolis OS 8.6搭建并测试CSV机密容器: ../海光安全虚拟化技术CSV/CSV机密容器-0.5.0/Anolis OS 8.6搭建并测试CSV机密容器.md
+      CC场景如何下载需要auth的镜像: ../海光安全虚拟化技术CSV/CSV机密容器-0.5.0/CC场景如何下载需要auth的镜像.md
\ No newline at end of file
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.1.0/\345\234\250kata CSV\350\231\232\346\213\237\346\234\272\344\270\255\344\275\277\347\224\250\346\234\272\345\257\206\345\256\271\345\231\250.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.1.0/\345\234\250kata CSV\350\231\232\346\213\237\346\234\272\344\270\255\344\275\277\347\224\250\346\234\272\345\257\206\345\256\271\345\231\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..278d112abebf3ffe7963839b92088e61d2a2a05b
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.1.0/\345\234\250kata CSV\350\231\232\346\213\237\346\234\272\344\270\255\344\275\277\347\224\250\346\234\272\345\257\206\345\256\271\345\231\250.md"	
@@ -0,0 +1,19 @@
+# 介绍
+
+[Kata Containers ](https://github.com/confidential-containers/kata-containers-CCv0)是一个使用虚拟化来提供隔离层的开源安全容器项目。Kata支持机密计算硬件技术，通过利用可信执行环境(Trusted Execution Environments)来保护客户的高度敏感的工作负载，以防止不受信任的实体（例如：云服务商）访问租客的敏感数据。
+
+在kata container中，您能够在在机密虚拟机中运行POD和容器，将主机/owner/管理员/CSP软件栈从kata 的TCB中移除，从而构建一个更强大的云原生多租户架构。具体做法是：在为每个租户使用的容器加密镜像远程Provisioning解密密钥前，先认证pod或容器是否已经运行在了经过认证的环境中。
+
+海光CPU支持安全虚拟化技术CSV(China Secure Virtualization)，CSV的设计目标是通过CSV虚拟机提供可信执行环境，适用的场景包括云计算、机密计算等。海光2号支持CSV1技术，提供虚拟机内存加密能力，采用国密SM4算法，不同的CSV虚拟机使用不同的加密密钥，密钥由海光安全处理器管理，主机无法解密虚拟机的加密内存。
+
+海光CSV加密虚拟机支持两种远程认证方式：
+
+- pre-attestation指需要在启动TEE之前能够执⾏行行attestation过程。在云上的CSV虚拟机启动的时候，对加载的ovmf，kernel，initrd，cmdline进行静态度量，生成measurement。线下的远程证明验证者对measurement进行验证，确保启动的CSV虚拟机是符合预期的。
+- runtime-attestation：在云上的CSV虚拟机运行的时候，产生带有硬件可执行环境的Quote的TLS证书。线下的远程证明验证者对TLS证书进行验证，确保CSV虚拟机运行在TEE中。
+
+基于以上两种远程证明，我们提供了一下两篇最佳实践文档：
+
+1. 在kata CSV虚拟机中基于pre-attestation使用机密容器的指南，请参考[文档](https://openanolis.cn/sig/coco/doc/533510702679267994)。
+1. 在kata CSV虚拟机中基于runtime-attestation使用机密容器的指南，请参考[文档](https://openanolis.cn/sig/coco/doc/533511548301020780?)。
+修改文档内容
+
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.1.0/\345\237\272\344\272\216 runtime attestation \344\275\277\347\224\250\346\234\272\345\257\206\345\256\271\345\231\250.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.1.0/\345\237\272\344\272\216 runtime attestation \344\275\277\347\224\250\346\234\272\345\257\206\345\256\271\345\231\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..51237303fa4c6e9c37616a05778dc1f51777fa6d
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.1.0/\345\237\272\344\272\216 runtime attestation \344\275\277\347\224\250\346\234\272\345\257\206\345\256\271\345\231\250.md"	
@@ -0,0 +1,650 @@
+本文主要为您介绍如何在kata环境中基于海光安全加密虚拟化功能CSV(China Secure Virtualization)技术，通过runtime-attestaion 认证方式，启动一个租户的加密容器镜像。
+
+# 前提条件
+
+请使用安装Hygon CPU的硬件设备，硬件信息参考如下：
+
+- CPU型号：Hygon C86 7291 32-core Processor
+- 固件版本：1600及以上
+- BIOS设置：开启SME
+
+BIOS选项SMEE用来控制是否打开内存加密功能，SMEE=Enable表示在BIOS中打开内存加密功能，SMEE=Disable表示在BIOS中关闭内存加密功能。
+
+## 1. 安装Anolis 8.4 操作系统
+
+请参考[Anolis 8.4 GA说明文档](https://mirrors.openanolis.cn/anolis/8.4/isos/GA/ReadMe.txt)安装anolis 8.4 GA。
+
+## 2. 升级kernel到5.10
+
+Anlois 8.4 的默认内核版本是4.19，5.10的内核上支持[CSV远程证明功能](https://gitee.com/anolis/cloud-kernel/pulls/14)。请升级kernel 到5.10版本。
+
+1. 请参考以下命令，添加Anolis的Experimental repo，并将kernel升级至5.10。
+```
+yum-config-manager --add-repo https://mirrors.openanolis.cn/anolis/8/Experimental/x86_64/os/ && \
+  yum update kernel
+```
+2. 配置bootloader。
+```
+grubby --update-kernel=ALL --args="mem_encrypt=on kvm_amd.sev=1"
+```
+3. 重启机器，请输入以下命令查看内核版本。
+```shell
+uname -r
+```
+预期输出：
+```shell
+5.10.134-12.an8.x86_64
+```
+
+**注意！！**  
+
+如果您使用的是Anolis 8.6 GA镜像，可能会碰到使能SEV之后，机器Hang住无法进入系统的情况。请参考以下步骤降级grub2-efi之后，可以正常启动这个特性
+
+```sh
+yum downgrade grub2-efi
+```
+
+## 3. 检查CSV使能状态 
+
+1.  在操作系统内执行：
+```
+dmesg | grep -i sev
+```
+
+下图表示CSV已经使能。 
+
+![](https://oss.openanolis.cn/sig/jyxnkmbnxviifztgmeep)
+
+2.  检查kvm_amd和ccp模块是否成功安装。
+```
+lsmod | grep kvm
+```
+下图表示成功安装。 
+
+![](https://oss.openanolis.cn/sig/ffhuletbduwrkhkkgaih)
+
+## 4. 使用hag检查固件版本信息
+
+1. 安装hag
+
+```sh
+yum-config-manager --add-repo https://mirrors.openanolis.org/inclavare-containers/anolis8.4 && \
+ rpm --import https://mirrors.openanolis.org/inclavare-containers/anolis8.4/RPM-GPG-KEY-rpm-sign && \
+ yum install -y hag
+```
+
+2. 通过hag获得平台状态
+
+```sh
+sudo hag --platform_status
+api_major:          1
+api_minor:          3
+platform_state:     CSV_STATE_WORKING
+owner:              PLATFORM_STATE_SELF_OWN
+chip_secure:        SECURE
+fw_enc:             ENCRYPTED
+fw_sign:            SIGNED
+es:                 CSV ES
+build id:           1644
+bootloader version: 0.0.0
+guest_count:        1
+supported csv guest:11
+platform_status command successful
+
+```
+
+注意：固件 build id 要大于等于 1600 才可以支持远程证明。
+
+## 5. 执行CSV 检查脚本，检查环境是否满足 (可选)
+```sh
+./check_csv_env.sh
+```
+
+脚本内容见附录
+
+# 背景信息
+
+![](https://oss.openanolis.cn/sig/mftnpcpuvawveyodvhtn)
+
+1. CSV VM启动；
+
+2. 下载加密镜像时才会通过attestation-agent将通过vm-attestation hypercall获取的包括attestation-report 、chip-id等内容的CSV VM evidence发送给verdictd server校验；
+
+3. 校验通过后virdictd才与attestation-agent建立基于rats-tls的可信硬件环境的安全通道、并将加密镜像的解密key通过该安全通道发送给attestation-agent；
+
+4. CSV VM利用步骤3获得的解密key解密镜像，运行工作负载
+
+# 步骤一：配置权限
+### 1. 关闭firewall
+ Linux系统下面自带了防火墙iptables，iptables可以设置很多安全规则。但是如果配置错误很容易导致各种网络问题。此处建议关闭firewall。
+执行如下操作：
+```
+sudo service firewalld stop
+```
+执行完毕后结果应类似如下：
+
+![](https://oss.openanolis.cn/sig/eiaokzmkrqohrzcldbyh)
+
+### 2. 关闭selinux
+ Security-Enhanced Linux（SELinux）是一个在內核中实施的强制存取控制（MAC）安全性机制。  
+为避免出现权限控制导致的虚拟机启动、访问失败等问题，此处建议关闭selinux。
+执行如下操作：
+```
+sudo setenforce 0
+sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
+```
+执行成功后：
+使用getenforce检查，结果应类似如下：
+
+![](https://oss.openanolis.cn/sig/wgkycimdpbhbeewmiqld)
+
+# 步骤二：安装kata 环境
+
+Kata Containers是一个开源的、致力于用轻量级虚拟机构建一个安全的容器运行时的实现，这些虚拟机在感觉和执行上与容器类似，但使用硬件虚拟化技术作为第二层防御，提供了更强的工作负载隔离。
+
+关于项目的更多信息，请参见[kata-container](https://github.com/confidential-containers/kata-containers-CCv0)。
+
+## 1. 安装kata-containers
+
+1. 请执行以下命令，安装kata-containers。
+```shell
+yum install -y kata-static
+```
+
+2. 运行以下命令，查看kata-containers是否安装成功。
+```shell
+tree /opt/kata/
+```
+
+返回结果示例如下，表示已安装成功。
+
+![](https://oss.openanolis.cn/sig/bdpavhcztunbimlzvnuz)
+
+## 2. 安装qemu
+此处使用的qemu基于6.2.0构建。
+```shell
+yum install -y qemu-system-x86_64
+```
+## 3. 安装guest kernel，initrd，ovmf
+ccv0-guest中包含kata运行CSV VM所需的guest kernel、initrd、OVMF、cmdline等文件。
+其中：
+guest的rootfs和kernel，需使用efi_secret的内核模块以支持向文件系统中注入secret，加入AA并修改AA设置，自行构建请参考[guest Rootfs and Kernel](https://github.com/confidential-containers/documentation/blob/main/demos/sev-demo/README.md#rootfs-and-kernel) ；
+这里提供的OVMF是基于f0f3f5aae7c4d346ea5e24970936d80dc5b60657 进行构建的，也可以使用[edk2-stable202108](https://github.com/tianocore/edk2/releases/tag/edk2-stable202108)后的版本自行构建，以支持CSV。
+
+```shell
+yum install -y ccv0-guest
+```
+
+cmdline中记录了CSV VM启动时所需的参数信息，需根据实际使用情况进行修改。可参考以下命令：
+```sh
+cat <<EOF | sudo tee /opt/csv/ccv0-guest/cmdline
+tsc=reliable no_timer_check rcupdate.rcu_expedited=1 i8042.direct=1 i8042.dumbkbd=1 i8042.nopnp=1 i8042.noaux=1 noreplace-smp reboot=k console=hvc0 console=hvc1 cryptomgr.notests net.ifnames=0 pci=lastbus=0 quiet panic=1 nr_cpus=`cat /proc/cpuinfo| grep processor | wc -l` scsi_mod.scan=none agent.config_file=/etc/agent-config.toml
+EOF
+```
+## 4. 安装kata-runtime
+
+kata-runtime运行CSV VM。
+
+```
+yum -y install kata-runtime
+```
+## 5. 配置kata-runtime
+执行以下命令，配置kata 运行时：
+这里修改了kata-runtime默认配置中的qemu、guest kernel && initrd && OVMF路径；
+使能confidential-guest选项并加入attestation-agent-config配置；
+将默认内存大小由2048调整为8000；
+将共享文件系统由"virtio-fs"调整为"virtio-9p"。
+```
+mkdir -p /etc/kata-containers/ && \
+cp /opt/kata/share/defaults/kata-containers/configuration.toml /etc/kata-containers/ && \
+cd /etc/kata-containers/ && \
+sed -i 's/opt\/kata\/bin\/qemu-system-x86_64/opt\/qemu\/bin\/qemu-system-x86_64/' configuration.toml && \
+sed -i 's/kata\/share\/kata-containers\/vmlinux.container/csv\/ccv0-guest\/vmlinuz-5.15.0-rc5+/' configuration.toml && \
+sed -i 's/image = \"\/opt\/kata\/share\/kata-containers\/kata-containers/initrd = \"\/opt\/csv\/ccv0-guest\/initrd.run/' configuration.toml && \
+sed -i 's/\# confidential_guest/confidential_guest/' configuration.toml && \
+sed -i 's/kernel_params = \"\"/kernel_params = \"agent.config_file=\/etc\/agent-config.toml\"/' configuration.toml && \
+sed -i 's/firmware = \"\"/firmware = \"\/opt\/csv\/ccv0-guest\/OVMF.fd\"/' configuration.toml && \
+sed -i 's/default_memory = 2048/default_memory = 8000/' configuration.toml && \
+sed -i 's/shared_fs = \"virtio-fs\"/shared_fs = \"virtio-9p\"/' configuration.toml && \
+sed -i 's/\#service_offload/service_offload/' configuration.toml
+```
+# 步骤三：安装containerd
+Containerd是一个行业标准的容器运行时，强调简单性、健壮性和可移植性。它可以作为Linux和Windows的守护进程，可以管理其主机系统的完整容器生命周期:图像传输和存储、容器执行和监督、底层存储和网络附件等。
+更多信息请参考[containerd](https://github.com/containerd/containerd)
+
+1. 执行以下命令，安装containerd
+```shell
+sudo yum install -y containerd
+```
+
+2. 启动containerd
+
+```shell
+sudo systemctl enable /etc/systemd/system/containerd.service
+sudo systemctl daemon-reload
+sudo service containerd restart
+```
+
+预期输出类似如下：
+```
+● containerd.service - containerd container runtime
+   Loaded: loaded (/etc/systemd/system/containerd.service; disabled; vendor preset: disabled)
+   Active: active (running) since Thu 2022-03-31 16:52:43 CST; 1s ago
+     Docs: https://containerd.io
+  Process: 1884520 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
+ Main PID: 1884522 (containerd)
+    Tasks: 34
+   Memory: 46.8M
+   CGroup: /system.slice/containerd.service
+           └─1884522 /usr/bin/containerd
+```
+
+# 步骤四：搭建kubenetes运行环境
+
+Kubernetes，也称为K8s，是一个用于管理跨多个主机的容器化应用程序的开源系统。它为应用程序的部署、维护和扩展提供了基本机制。
+更多信息请参考 [kubernetes](https://github.com/kubernetes/kubernetes) 项目介绍。
+## 1.  系统环境配置
+- 确保 br_netfilter 模块被加载
+
+```shell
+modprobe br_netfilter
+```
+
+- 允许 iptables 检查桥接流量
+
+```shell
+cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
+br_netfilter
+EOF
+
+cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
+net.bridge.bridge-nf-call-ip6tables = 1
+net.bridge.bridge-nf-call-iptables = 1
+EOF
+sudo sysctl --system
+```
+
+- 关闭swap
+
+```shell
+swapoff –a
+```
+
+## 2. 安装 kubeadm、kubelet 和 kubectl
+
+- 配置repo
+
+```shell
+cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
+[kubernetes]
+name=Kubernetes
+baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
+enabled=1
+gpgcheck=1
+repo_gpgcheck=1
+gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
+EOF
+
+sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
+```
+
+- 设置服务文件
+
+```shell
+sudo mkdir -p  /etc/systemd/system/kubelet.service.d/
+cat <<EOF | sudo tee  /etc/systemd/system/kubelet.service.d/0-containerd.conf
+[Service]
+Environment="KUBELET_EXTRA_ARGS=--container-runtime=remote --runtime-request-timeout=15m --container-runtime-endpoint=unix:///run/containerd/containerd.sock"
+EOF
+
+cat << EOF | sudo tee /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf
+[Service]
+Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf"
+Environment="KUBELET_CONFIG_ARGS=--config=/var/lib/kubelet/config.yaml"
+
+#This is a file that "kubeadm init" and "kubeadm join" generates at runtime, populating the KUBELET_KUBEADM_ARGS variable dynamically
+
+EnvironmentFile=-/var/lib/kubelet/kubeadm-flags.env
+
+#This is a file that the user can use for overrides of the kubelet args as a last resort. Preferably, the user should use
+#the .NodeRegistration.KubeletExtraArgs object in the configuration files instead. KUBELET_EXTRA_ARGS should be sourced from this file.
+
+EnvironmentFile=-/etc/sysconfig/kubelet
+ExecStart=
+ExecStart=/usr/bin/kubelet \$KUBELET_KUBECONFIG_ARGS \$KUBELET_CONFIG_ARGS \$KUBELET_KUBEADM_ARGS \$KUBELET_EXTRA_ARGS
+EOF
+systemctl enable kubelet.service
+```
+## 3. 初始化k8s 环境
+```shell
+sudo kubeadm init --cri-socket /run/containerd/containerd.sock --pod-network-cidr=10.244.0.0/16 --image-repository registry.aliyuncs.com/google_containers
+
+mkdir -p $HOME/.kube
+sudo /bin/cp -f /etc/kubernetes/admin.conf $HOME/.kube/config
+sudo chown $(id -u):$(id -g) $HOME/.kube/config
+```
+## 4. 允许pod使用master：
+默认情况下，集群不会在主节点中调度 Pod。 要启用主节点调度：
+```shell
+su
+export KUBECONFIG=/etc/kubernetes/admin.conf
+kubectl taint nodes --all node-role.kubernetes.io/master-
+kubectl taint nodes --all node-role.kubernetes.io/control-plane-
+```
+## 5. 安装flannel网络
+[Flannel](https://github.com/flannel-io/flannel#flannel) 是一个非常简单的能够满足 Kubernetes 所需要的覆盖网络。   Flannel使用Kubernetes或etcd来存储网络配置、分配的子网和主机公共IP等信息。数据包则通过VXLAN、UDP或host-gw这些类型的后端机制进行转发。  
+```shell
+wget --retry-connrefused --waitretry=1 --read-timeout=20 --timeout=15 --tries=0 https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml  -O $HOME/kube-flannel.yml
+
+kubectl apply -f $HOME/kube-flannel.yml
+```
+## 6. 检查k8s环境的状态
+```shell
+kubectl get pods --all-namespaces
+```
+预期输出：
+
+
+![](https://oss.openanolis.cn/sig/teaorurqmoroqdgibwnj)
+
+
+# 步骤五：安装并启动verdictd
+
+Verdictd是一种远程认证实现，由一组构建块组成，这些构建块利用Intel/AMD的安全特性来发现、验证和支持关键的基础安全和机密计算用例。它依靠RATS-TLS应用远程认证基础和标准规范来维护平台数据收集服务和高效的验证引擎来执行全面的信任评估。这些信任评估可用于管理应用于任何给定工作负载的不同信任和安全策略。
+更多信息请参考[verdictd](https://github.com/inclavare-containers/verdictd)项目文档。
+## 1. 请执行以下命令，安装verdictd
+
+```shell
+yum install -y verdictd
+```
+
+## 2. 配置CSV OPA文件
+使用/opt/csv/calculate_hash.py计算measure
+
+```sh
+yum install -y gop 
+/opt/csv/calculate_hash.py --ovmf  /opt/csv/ccv0-guest/OVMF.fd --kernel /opt/csv/ccv0-guest/vmlinuz-5.15.0-rc5+  --initrd /opt/csv/ccv0-guest/initrd.run.img --cmdline /opt/csv/ccv0-guest/cmdline
+```
+
+输出结果类似如下：
+```sh
+Calculating hash of kernel at /opt/csv/ccv0-guest/vmlinuz-5.15.0-rc5+
+Calculating hash of initrd at /opt/csv/ccv0-guest/initrd.run.img
+Calculating hash of kernel params (/opt/csv/ccv0-guest/cmdline)
+Firmware Digest:  OJXIhq3PHbknNmpAIy8YpUHOpY0wvGRXULOW8djVAZA=
+```
+
+
+配置csvData
+```sh
+mkdir -p /opt/verdictd/opa/ && cat <<EOF | sudo tee /opt/verdictd/opa/csvData
+{
+    "measure": ["OJXIhq3PHbknNmpAIy8YpUHOpY0wvGRXULOW8djVAZA="]
+}
+EOF
+```
+
+配置csvPolicy.rego
+```sh
+cat <<EOF | sudo tee /opt/verdictd/opa/csvPolicy.rego
+
+package policy
+
+# By default, deny requests.
+default allow = false
+
+allow {
+    measure_is_grant
+}
+
+
+measure_is_grant {
+    count(data.measure) == 0
+}
+
+measure_is_grant {
+    count(data.measure) > 0
+    input.measure == data.measure[_]
+}
+EOF
+```
+
+# 步骤六：制作加密镜像
+
+## 1. 制作加密镜像
+
+可参考[Generate encrypted container image](https://github.com/inclavare-containers/verdictd#generate-encrypted-container-image)制作加密镜像。
+在本例中以 docker.io/zhouliang121/alpine-84688df7-2c0c-40fa-956b-29d8e74d16c1-gcm:latest 为例进行测试。
+
+## 2. 部署镜像密钥
+
+```
+mkdir -p /opt/verdictd/keys/ && echo 1111111111111111111111111111111 > /opt/verdictd/keys/84688df7-2c0c-40fa-956b-29d8e74d16c1
+```
+
+## 3. 修改镜像policy
+以docker.io/zhouliang121/alpine-84688df7-2c0c-40fa-956b-29d8e74d16c1-gcm:latest 为例：
+```sh
+cat <<EOF | sudo tee /opt/verdictd/image/policy.json
+{
+    "default": [{"type": "insecureAcceptAnything"}],
+    "transports": {
+        "docker": {
+            "docker.io/zhouliang121/":
+            [{"type": "insecureAcceptAnything"}]
+        }
+    }
+}
+EOF
+```
+
+4. 启动verdictd
+```sh
+verdictd --listen 0.0.0.0:20002 --verifier csv --attester nullattester --client-api 127.0.0.1:20001 --mutual
+```
+当Verdictd启动后，Verdictd在端口监听地址0.0.0.0:20002监听来自attestation agent的远程证明请求。
+
+# 步骤七：部署加密镜像
+## 1. 创建RuntimeClass对象kata
+用户可以使用RuntimeClass为pod指定不同的运行时，这里使用kata作为验证时使用的运行时。
+
+在集群中执行以下命令，创建RuntimeClass对象kata。
+```shell
+cat <<-EOF | kubectl apply -f -
+apiVersion: node.k8s.io/v1
+kind: RuntimeClass
+metadata:
+  name: kata
+handler: kata
+EOF
+```
+## 2. 部署pod
+如果 pod 的 runtimeClassName 设置为 kata，CRI 插件会使用 Kata Containers 运行时运行 pod。
+执行以下命令，部署名称为alpine的pod。
+```shell
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  name: nginx-sandbox
+spec:
+  runtimeClassName: kata
+  containers:
+  - image: docker.io/zhouliang121/alpine-84688df7-2c0c-40fa-956b-29d8e74d16c1-gcm:latest
+    command:
+      - top
+    imagePullPolicy: IfNotPresent
+    name: alpine
+  restartPolicy: Never
+EOF
+
+```
+## 3. 测试加密镜像是否部署成功
+
+执行以下命令，查看加密镜像是否部署成功：
+```
+kubectl get pods
+```
+预期输出：
+
+![](https://oss.openanolis.cn/sig/txdolqfbikvgtxdsbpfw)
+
+执行如下命令，查看加密镜像是否部署成功：
+```shell
+kubectl describe pod nginx-sandbox --namespace=default
+```
+
+verdictd预期输出：
+
+![](https://oss.openanolis.cn/sig/bdzzruufvjybxjigmbqv)
+
+从上述pod信息和virdictd输出信息可知已部署成功。
+
+# 附录
+
+## check_csv_env.sh内容
+
+```sh
+#!/bin/bash
+
+# version: 1.0
+# check the CSV confidential container verification env on Anolis8
+
+
+#set -x
+
+KERNEL_VERSION_MIN=5.10.
+CSV_VERSION_MIN=1600
+
+
+
+# check CPU model
+check_cpu_model()
+{
+    echo -e "\n===========================\n"
+    echo  -e "CHECK IF HYGON CPU: \n"
+    echo  -e "lscpu: "
+    lscpu
+
+    is_hygon_cpu=`cat /proc/cpuinfo | grep Hygon`
+
+    echo -ne "\ncheck if Hygon CPU: "
+    if [ -n "$is_hygon_cpu" ];then
+        echo -e "\tPass!\n"
+        echo -e "===========================\n"
+    else
+        echo -e "\tFaild!"
+        echo -e "\tPlease use Hygon CPU to support CSV!\n"
+        exit
+    fi
+}
+
+# check kernel version
+check_kernel_version()
+{
+    echo  -e "CHECK KERNEL VERSION: \n"
+    uname_r=`uname -r`
+
+    echo -e "\tcurrent version: ${uname_r}"
+
+    echo -ne "\ncheck kernel version: "
+    if [ "X${uname_r:0:5}" = "X${KERNEL_VERSION_MIN}" ];then
+        echo -e "\tPass!\n"
+        echo -e "===========================\n"
+    else
+        echo -e "\tFaild!"
+        echo -e "\tkernel version should be 5.10.x serious!\n"
+        exit
+    fi
+}
+
+#check CSV enabled
+check_csv_enabled()
+{
+    echo -e "CHECK CSV ENABLED: \n"
+
+    echo -e "dmesg | grep -i sev"
+    dmesg | grep -i sev
+
+
+    echo -en "\ncheck CSV enabled: "
+    csv_support=`dmesg | grep -i "sev enabled"`
+    if [ -z "$csv_support" ];then
+        echo -e "\tFaild!"
+        echo -e "\tPlease enable the CSV feature!\n"
+        exit
+    else
+        echo -e "\tPass!\n"
+        echo -e "===========================\n"
+    fi
+}
+
+#check CSV version
+check_csv_version()
+{
+    set -e
+    echo -e "CHECK CSV VERSION: \n"
+    echo -e "sudo hag --platform_status"
+    sudo hag --platform_status
+
+    csv_plat_stat=`sudo hag --platform_status | grep "build id"`
+    csv_version=${csv_plat_stat:0-4:4}
+    echo -e "\n\tcurrent version: ${csv_version}"
+
+    echo -ne "\ncheck CSV version: "
+    if [ "$csv_version" -gt "$CSV_VERSION_MIN" ];then
+        echo -e "\tPass!\n"
+        echo -e "===========================\n"
+    else
+        echo -e "\tFaild!"
+        echo -e "\tThe CSV version should be greater than $CSV_VERSION_MIN!\n"
+        exit
+    fi
+    set +e
+}
+
+#check firewalld stat
+check_firewalld_stat()
+{
+    set -e
+    echo -ne "CHECK FIREWALLD DISABLED: "
+
+    firewalld_stat=`systemctl show -p ActiveState --value firewalld`
+    if [ $firewalld_stat = "active" ];then
+        echo -e "\tFaild!"
+        echo -e "\tPlease disable the firewalld service!\n"
+        exit
+    else
+        echo -e "\tPass!\n"
+        echo -e "===========================\n"
+    fi
+    set +e
+}
+
+#check selinux stat
+check_selinux_stat()
+{
+    set -e
+    echo -ne "CHECK SELINUX DISABLED: "
+
+    selinux_stat=`getenforce`
+    if [ $selinux_stat = "Enforcing" ];then
+        echo -e  "\tFaild!"
+        echo -e  "\tPlease disable or permissive the selinux!\n"
+        exit
+    else
+        echo -e "\tPass!\n"
+        echo -e "===========================\n"
+    fi
+    set +e
+}
+
+check_cpu_model
+check_kernel_version
+check_csv_enabled
+check_csv_version
+check_firewalld_stat
+check_selinux_stat
+echo -e "CSV base env all pass! Enjoy!\n"
+```
+
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/Anolis OS 8.6\346\220\255\345\273\272\345\271\266\346\265\213\350\257\225CSV\346\234\272\345\257\206\345\256\271\345\231\250.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/Anolis OS 8.6\346\220\255\345\273\272\345\271\266\346\265\213\350\257\225CSV\346\234\272\345\257\206\345\256\271\345\231\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..2ad0bb1b14a8e5ac6c2e4700e30aa5638b303490
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/Anolis OS 8.6\346\220\255\345\273\272\345\271\266\346\265\213\350\257\225CSV\346\234\272\345\257\206\345\256\271\345\231\250.md"	
@@ -0,0 +1,255 @@
+# Anolis OS 8.6搭建并测试CSV机密容器
+
+本文主要为您介绍如何基于安全加密虚拟化CSV技术，通过远程证明启动一个租户的加密容器镜像。
+
+## 前提条件
+
+### 1. 安装Anolis 8.6 操作系统
+
+请参考[Anolis 8.6 GA说明文档](https://mirrors.openanolis.cn/anolis/8.6/isos/GA/)安装anolis 8.6 GA。
+
+### 2. 下载依赖
+
+[hygon-devkit]([anolis/hygon-devkit - 码云 - 开源中国 (gitee.com)](https://gitee.com/anolis/hygon-devkit/tree/master))中包含了部署CSV机密容器需要的脚本和相关组件的rpm包
+
+```
+git clone https://gitee.com/anolis/hygon-devkit.git
+```
+
+### 3. 升级内核到5.10
+
+- 安装内核，并重启机器
+
+```shell
+cd hygon-devkit/csv
+sudo ./install_kernel_5.10_static.sh
+reboot
+```
+
+- 重启后，请检查机器的CSV和SME使能状态。
+
+```shell
+cd hygon-devkit/csv
+sudo ./check_sme_csv.sh
+```
+
+- 预期结果如下：
+
+```shell
+SME is enabled!
+CSV is enabled!
+```
+
+
+
+## 背景信息
+
+![cncc](../../../../assets/csv_overview.png)
+
+CSV Pod 级机密容器架构基于 Kata Containers 项目，最大区别是将基于普通虚拟化技术实现的轻量级 Sandbox Pod替换为基于机密计算技术实现的轻量级 TEE Pod，目的是将特定租户的整个 Pod 以及其中的容器运行在受 CPU TEE 保护的执行环境中。除此之外，TEE Pod 内部还额外集成了 image-rs 和 attestation-agent 等组件，它们负责实现容器镜像的拉取、授权、验签、解密、远程证明以及秘密注入等安全特性。
+机密容器的基本运行过程为：
+
+- 用户使用标准工具制作一个签名和/或加密的受保护的容器镜像，并上传到容器镜像仓库中。
+- 用户命令 Kubernetes 启动这个受保护的容器镜像。kubelet 会向 containerd 发起创建 Pod 的 CRI 请求，containerd 则把请求转发给 kata-runtime。
+- kata runtime 与 Key broker service（simple kbs）建立安全会话，并进行基于CPU TEE 硬件的身份认证与授权。KBS基于安全可信信道发送敏感数据给kata runtime。kata runtime 调用QEMU 将秘密信息注入到guest userland中。之后再调用 QEMU 启动 Pod。
+- CPU TEE 执行初始化，最终启动 kata-agent 监听后续请求。
+- kubelet 向 containerd 发起 Image Pulling 的 CRI 请求，containerd 则把请求转发给 kata-runtime，最终 kata-agent 收到请求并通过 image-rs 子模块提供的容器镜像管理功能，在 TEE 内安全地执行拉取、验签、解密、unpack 以及挂载容器镜像的操作。
+
+## 步骤一：部署测试集群
+
+### 运行一键部署脚本
+
+```
+sudo su root
+cd hygon-devkit/csv/confidential-containers
+./deploy-confidential_containers-0.5.0.sh
+```
+
+> 部署相关的详细内容请参考[Anolis OS 8.6部署支持CSV机密容器的k8s](./Anolis OS 8.6部署支持CSV机密容器的k8s.md)。
+
+## 步骤二：启动Simple KBS
+
+[simple kbs](https://github.com/confidential-containers/simple-kbs#readme)是一个密钥代理服务，可以存储并向 workload 提供 secret 。对于 CSV 加密容器示例来说，需要从simple kbs 中获取 secret ，并用于解密已加密的容器。
+在步骤三的示例二中，本文提供了一个简单的加密镜像( docker.io/pawsonfang/busybox:encrypted )，该镜像使用 simple kbs 已经存在的密钥来解密，同时对 policy 不进行校验。此加密镜像只作为测试使用，如您想用于自己的生产用例中，请参考文档[制作一个新的加密镜像并部署](./制作一个新的加密镜像并部署.md)。
+
+要了解有关创建 policy 的更多信息，请参考[自定义simple-kbs的policy](./自定义simple-kbs的policy.md)。
+
+```shell
+cd /opt/simple-kbs 
+sudo docker compose up -d
+```
+
+## 步骤三：运行workload
+
+attestation agent 支持三种CSV平台相关的KBC：[offline_fs_kbc](https://github.com/confidential-containers/attestation-agent/tree/main/kbc/src/offline_fs_kbc), [offline_sev_kbc](https://github.com/confidential-containers/attestation-agent/tree/main/kbc/src/offline_sev_kbc) 和 [online_sev_kbc](https://github.com/confidential-containers/attestation-agent/tree/main/kbc/src/online_sev_kbc)。
+
+- offline fs KBC 事先把密钥放置在initrd中，用于验签容器镜像。缺点是每次更新密钥或policy，需要重新制作initrd。
+- offline sev KBC 在**运行时**不会与 Simple KBS 进行通信，而是使用在**VM Boot时期**通过QEMU注入的secret。该机制的缺点是对注入的 secret 长度有限制。
+- online sev KBC 在offline sev KBC的基础上，支持在**运行时**发出请求。online sev KBC 在VM Boot时期通过QEMU注入connection。注入的connection包含一个对称密钥，用于加密和验证 KBC 发出的在线请求。 该连接受 CSV秘密注入过程保护，该过程提供机密性、完整性并防止重放攻击。 simple-kbs 为每个连接生成一个新的对称密钥。 KBC 要求每个在线secret都带有随机 guid 以防止重放攻击。
+
+> 本文以online_sev_kbc为主，oflline_sev_kbc 请参考[使用offline_sev_kbc模式运行加密容器](./使用offline_sev_kbc模式运行加密容器.md)，offline_fs_kbc 请参考[使用offline_fs_kbc模式运行签名容器](./使用offline_fs_kbc模式运行签名容器.md)
+
+### 示例一：运行一个未加密的容器镜像
+
+为了验证主机上不存在容器镜像，应该登录到 k8s 节点并确保以下命令返回空结果：
+
+```shell
+sudo crictl  -r  unix:///run/containerd/containerd.sock image ls | grep bitnami/nginx
+```
+
+启动POD
+
+```shell
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    run: nginx
+  name: nginx
+spec:
+  containers:
+  - image: bitnami/nginx:1.22.0
+    name: nginx
+  dnsPolicy: ClusterFirst
+  runtimeClassName: kata
+EOF
+```
+
+预期结果：
+
+```shell
+pod/nginx created
+```
+
+查看 pod 状态：
+
+```shell
+kubectl get pods
+```
+
+预期结果如下，注意， STATUS 要是 Running 。
+
+```shell
+NAME    READY   STATUS    RESTARTS   AGE
+nginx   1/1     Running   0          3m50s
+```
+
+### 示例二：运行一个加密容器
+
+#### 基于online sev KBC运行加密容器
+
+- 编辑 kata 配置文件(kata 的配置文件路径：/opt/confidential-containers/share/defaults/kata-containers/configuration-qemu-csv.toml)：
+
+    - 设置simple-kbs的ip地址
+
+      ```
+      kbs_ip="$(ip -o route get to 8.8.8.8 | sed -n 's/.*src \([0-9.]\+\).*/\1/p')"
+      sudo sed -i 's#^guest_pre_attestation_kbs_uri = .*#guest_pre_attestation_kbs_uri = "'$kbs_ip':44444"#' /opt/confidential-containers/share/defaults/kata-containers/configuration-qemu-csv.toml
+      ```
+
+    - 设置kbs_mod为online模式，initrd指向支持online_sev_kbc的
+
+      ```
+      initrd = "/opt/confidential-containers/share/kata-containers/kata-ubuntu-20.04-csv-online_sev_kbc.initrd"
+      guest_pre_attestation_kbs_mode="online"
+      ```
+
+
+- 启动POD
+
+```shell
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    run: test-en-online
+  name: test-en-online
+spec:
+  containers:
+  - image: docker.io/pawsonfang/busybox:encrypted
+    name: test-en-online
+    imagePullPolicy: Always
+  dnsPolicy: ClusterFirst
+  restartPolicy: Never
+  runtimeClassName: kata-qemu-csv
+EOF
+```
+
+- 查看 pod 是否启动成功：
+
+```shell
+kubectl get pods
+```
+
+- 预期结果如下：
+
+```shell
+NAME                READY   STATUS    RESTARTS   AGE
+test-en-online      1/1     Running   0          146m
+```
+
+#### 基于offline sev KBC运行加密容器
+
+请参考[使用offline_sev_kbc模式运行加密容器](./使用offline_sev_kbc模式运行加密容器.md)
+
+### 示例三：运行一个签名容器
+
+> 示例采用已存在的签名镜像，想要制作新的签名镜像，请参考[制作一个新的签名镜像并部署](./制作一个新的签名镜像并部署.md)。
+
+#### 基于online sev KBC运行签名容器
+
+- 编辑kata配置文件(kata 的配置文件路径：/opt/confidential-containers/share/defaults/kata-containers/configuration-qemu-csv.toml)
+
+修改kata为online_sev_kbc模式，同时使能镜像验签功能：
+
+```
+initrd = "/opt/confidential-containers/share/kata-containers/kata-ubuntu-20.04-csv-online_sev_kbc.initrd"
+guest_pre_attestation_kbs_mode="online"
+kernel_params = "agent.config_file=/etc/agent-config.toml agent.enable_signature_verification=true "
+```
+
+- 启动 Pod
+
+```shell
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    run: test-sign-online
+  name: test-sign-online
+spec:
+  containers:
+  - image: docker.io/pawsonfang/mybusybox
+    name: test-sign-online
+    imagePullPolicy: Always
+  dnsPolicy: ClusterFirst
+  restartPolicy: Never
+  runtimeClassName: kata-qemu-csv
+EOF
+```
+
+- 查看 pod 是否启动成功：
+
+```shell
+kubectl get pods
+```
+
+- 预期结果如下：
+
+```shell
+NAME                READY   STATUS    RESTARTS   AGE
+test-sign-online     1/1     Running   0          31h
+```
+
+#### 基于offline fs KBC运行签名容器
+
+请参考[使用offline_fs_kbc模式运行加密容器](./使用offline_fs_kbc模式运行签名容器.md)
+
+
+
+## 附录
+
+> 对于一些私人仓库，需要登录，才能下载镜像，具体方法请参考[CC场景如何下载需要auth的镜像](./CC场景如何下载需要auth的镜像.md)。
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/Anolis OS 8.6\351\203\250\347\275\262\346\224\257\346\214\201CSV\346\234\272\345\257\206\345\256\271\345\231\250\347\232\204k8s.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/Anolis OS 8.6\351\203\250\347\275\262\346\224\257\346\214\201CSV\346\234\272\345\257\206\345\256\271\345\231\250\347\232\204k8s.md"
new file mode 100644
index 0000000000000000000000000000000000000000..08f07c5b88e37962bbcc6a51cf94c420fbd5cda4
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/Anolis OS 8.6\351\203\250\347\275\262\346\224\257\346\214\201CSV\346\234\272\345\257\206\345\256\271\345\231\250\347\232\204k8s.md"	
@@ -0,0 +1,444 @@
+# Anolis OS 8.6部署支持CSV机密容器的k8s
+
+本文主要为您介绍如何基于安全加密虚拟化CSV技术，部署k8s环境。
+
+## 前提条件
+
+### 1. 下载依赖
+
+[hygon-devkit]([anolis/hygon-devkit - 码云 - 开源中国 (gitee.com)](https://gitee.com/anolis/hygon-devkit/tree/master))中包含了部署CSV机密容器需要的脚本和相关组件的rpm包
+
+```
+git clone https://gitee.com/anolis/hygon-devkit.git
+```
+
+### 2. 使能安全功能
+
+#### 安装安全工具hag
+
+hag 是 CSV 平台的命令行管理工具，请按照以下步骤安装 hag：
+
+```shell
+cd hygon-devkit/csv/confidential-containers/
+sudo rpm -ivh --nodeps RPMs/hag-1.0.1868-1.x86_64.rpm
+```
+
+#### 导入通用安全证书
+
+只有导入通用安全证书，才能开启安全功能，如CSV、TPM等
+
+```
+sudo /opt/hygon/bin/hag general hgsc_import
+```
+
+
+
+## 步骤一：部署测试集群
+
+本步骤为您提供快速部署**单节点测试集群**的步骤。您可以根据您的需求，灵活部署集群。
+
+### 配置权限
+
+#### 启用br_netfilter
+
+```
+# 临时启用
+sudo modprobe br_netfilter
+# 永久启用
+echo "br_netfilter" > /etc/modules-load.d/br_netfilter.conf
+```
+
+#### 启用vhost-vsock/vhost-net
+
+```
+# 临时启用
+modprobe vhost-vsock
+modprobe vhost-net
+# 永久启用
+echo "vhost-vsock vhost-net" > /etc/modules-load.d/vhost.conf
+```
+
+#### 关闭firewall
+
+Linux系统下面自带了防火墙iptables，iptables可以设置很多安全规则。但是如果配置错误很容易导致各种网络问题。此处建议关闭firewall。 执行如下操作：
+
+```
+# 临时关闭
+sudo service firewalld stop
+# 关闭自启动
+systemctl disable firewalld.service
+```
+
+检查 firewall 状态：
+
+```shell
+service firewalld status
+```
+
+预期结果如下：
+
+```shell
+Redirecting to /bin/systemctl status firewalld.service
+● firewalld.service - firewalld - dynamic firewall daemon
+   Loaded: loaded (/usr/lib/systemd/system/firewalld.service; disabled; vendor preset: enabled)
+   Active: inactive (dead)
+     Docs: man:firewalld(1)
+```
+
+#### 关闭selinux
+
+Security-Enhanced Linux（SELinux）是一个在内核中实施的强制存取控制（MAC）安全性机制。为避免出现权限控制导致的虚拟机启动、访问失败等问题，此处建议关闭selinux。执行如下操作：
+
+```shell
+# 临时关闭，重启失效
+setenforce 0
+# 永久关闭
+sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
+```
+
+预期结果如下：
+
+```shell
+setenforce: SELinux is disabled
+```
+
+#### 允许 iptables 检查桥接流量
+
+```
+cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
+net.bridge.bridge-nf-call-ip6tables = 1
+net.bridge.bridge-nf-call-iptables = 1
+EOF
+sudo sysctl --system
+```
+
+#### 关闭swap
+
+```
+# 临时关闭
+swapoff -a
+# 永久关闭
+sed -ri '/\sswap\s/s/^#?/#/' /etc/fstab
+```
+
+### 安装docker
+
+- 请执行下列脚本安装 docker。
+
+```shell
+sudo yum install yum-utils
+sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
+sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin --allowerasing
+sudo systemctl enable --now docker
+systemctl status docker.service
+```
+
+### 配置containerd
+
+自动生成默认的config.toml
+
+```shell
+sudo su root
+containerd config default > /etc/containerd/config.toml
+```
+
+由于默认的 config.toml 使用的是国外的镜像，国内有可能无法访问。请参考以下命令修改为国内镜像。
+
+```shell
+sed -i 's#registry.k8s.io/pause:3.6#registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.6#g' /etc/containerd/config.toml
+```
+
+启动 containerd
+
+```shell
+systemctl daemon-reload
+systemctl enable --now containerd
+systemctl status containerd
+```
+
+### 部署单节点的Kubernetes cluster
+
+- 请参考[kubernetes](https://github.com/kubernetes/kubernetes)官方指南安装Kubernetes cluster。最低 Kubernetes 版本应为 1.24。
+
+```
+cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
+[kubernetes]
+name=Kubernetes
+baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
+enabled=1
+gpgcheck=1
+repo_gpgcheck=1
+gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
+EOF
+
+sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
+```
+
+- 配置Kubelet 使用 containerd
+
+```shell
+cat << EOF | sudo tee  /usr/lib/systemd/system/kubelet.service.d/0-containerd.conf
+[Service]                                                 
+Environment="KUBELET_EXTRA_ARGS=--container-runtime=remote --runtime-request-timeout=15m --container-runtime-endpoint=unix:///run/containerd/containerd.sock"
+EOF
+systemctl enable --now kubelet
+```
+
+- 初始化 kubeadm
+
+```shell
+systemctl daemon-reload
+systemctl restart containerd
+systemctl restart kubelet
+# 此处--pod-network-cidr=10.244.0.0/16，与后续flannel的地址相同
+sudo kubeadm init --cri-socket /run/containerd/containerd.sock --pod-network-cidr=10.244.0.0/16 --image-repository registry.aliyuncs.com/google_containers
+```
+
+- 设置用户kubectl执行权限(注意：重启kubelet服务或系统时，可能需要重新执行下述命令)
+
+```
+  mkdir -p $HOME/.kube
+  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
+  sudo chown $(id -u):$(id -g) $HOME/.kube/config
+```
+
+- 控制平面节点隔离
+
+  默认情况下，出于安全原因，你的集群不会在控制平面节点上调度 Pod。 如果你希望能够在控制平面节点上调度 Pod，例如单机 Kubernetes 集群，请运行:
+
+  ```shell
+  kubectl taint nodes --all node-role.kubernetes.io/control-plane-
+  ```
+
+- 安装flannel网络插件
+
+  [Flannel](https://github.com/flannel-io/flannel#flannel) 是一个非常简单的能够满足 Kubernetes 所需要的覆盖网络。 Flannel使用Kubernetes或etcd来存储网络配置、分配的子网和主机公共IP等信息。数据包则通过VXLAN、UDP或host-gw这些类型的后端机制进行转发。
+
+  ```shell
+  wget --retry-connrefused --waitretry=1 --read-timeout=20 --timeout=15 --tries=0 https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml  -O $HOME/kube-flannel.yml
+  
+  kubectl apply -f $HOME/kube-flannel.yml
+  ```
+
+- 检查k8s环境状态
+
+  ```
+  kubectl get pods --all-namespaces
+  ```
+
+  预期结果如下：
+
+  ```
+  NAMESPACE      NAME                                 READY   STATUS    RESTARTS   AGE
+  kube-flannel   kube-flannel-ds-9nnrr                1/1     Running   0          34m
+  kube-system    coredns-7bdc4cb885-b4vld             1/1     Running   0          36m
+  kube-system    coredns-7bdc4cb885-k9t2c             1/1     Running   0          36m
+  kube-system    etcd-anolis-k8s                      1/1     Running   2          36m
+  kube-system    kube-apiserver-anolis-k8s            1/1     Running   2          36m
+  kube-system    kube-controller-manager-anolis-k8s   1/1     Running   2          36m
+  kube-system    kube-proxy-sjj9t                     1/1     Running   0          36m
+  kube-system    kube-scheduler-anolis-k8s            1/1     Running   2          36m
+  ```
+
+## 步骤二：部署Confidential Containers
+
+### 安装支持CSV的kata-containers
+
+- 请执行以下命令，安装kata-containers。
+
+```shell
+cd hygon-devkit/csv/confidential-containers/
+sudo rpm -ivh --nodeps RPMs/kata-containers-0.5.0-1.x86_64.rpm
+```
+
+- 运行以下命令，查看kata-containers是否安装成功。
+
+```shell
+tree /opt/confidential-containers/
+```
+
+返回结果示例如下，表示已安装成功。
+
+```
+/opt/confidential-containers/
+├── bin
+│   ├── csv-measure.py
+│   ├── cloud-hypervisor
+│   ├── containerd
+│   ├── containerd-shim-kata-v2
+│   ├── kata-collect-data.sh
+│   ├── kata-monitor
+│   ├── kata-runtime
+│   └── qemu-system-x86_64
+├── libexec
+│   └── virtiofsd
+├── runtime-rs
+│   └── bin
+│       └── containerd-shim-kata-v2
+└── share
+    ├── bash-completion
+    │   └── completions
+    │       └── kata-runtime
+    ├── defaults
+    │   └── kata-containers
+    │       ├── configuration-clh.toml
+    │       ├── configuration-dragonball.toml
+    │       ├── configuration-qemu-csv.toml
+    │       ├── configuration-qemu.toml
+    │       ├── configuration-remote.toml
+    │       └── configuration.toml -> configuration-qemu.toml
+    ├── kata-containers
+    │   ├── config-5.19.2
+    │   ├── kata-containers.img -> kata-ubuntu-latest.image
+    │   ├── kata-containers-initrd-csv.img -> kata-ubuntu-20.04-csv-online_sev_kbc.initrd
+    │   ├── kata-ubuntu-20.04-csv-offline_fs_kbc.initrd
+    │   ├── kata-ubuntu-20.04-csv-offline_sev_kbc.initrd
+    │   ├── kata-ubuntu-20.04-csv-online_sev_kbc.initrd
+    │   ├── kata-ubuntu-latest.image
+    │   ├── vmlinux-5.19.2-102cc
+    │   ├── vmlinux-5.19.2-102cc-csv
+    │   ├── vmlinux.container -> vmlinux-5.19.2-102cc
+    │   ├── vmlinux-csv.container -> vmlinux-5.19.2-102cc-csv
+    │   ├── vmlinuz-5.19.2-102cc
+    │   ├── vmlinuz-5.19.2-102cc-csv
+    │   ├── vmlinuz.container -> vmlinuz-5.19.2-102cc
+    │   └── vmlinuz-csv.container -> vmlinuz-5.19.2-102cc-csv
+    ├── kata-qemu
+    │   └── qemu
+    │       ├── bios-256k.bin
+    │       ├── bios.bin
+    │       ├── bios-microvm.bin
+    │       ├── edk2-aarch64-code.fd
+    │       ├── edk2-arm-code.fd
+    │       ├── edk2-arm-vars.fd
+    │       ├── edk2-i386-code.fd
+    │       ├── edk2-i386-secure-code.fd
+    │       ├── edk2-i386-vars.fd
+    │       ├── edk2-licenses.txt
+    │       ├── edk2-x86_64-code.fd
+    │       ├── edk2-x86_64-secure-code.fd
+    │       ├── efi-virtio.rom
+    │       ├── firmware
+    │       │   ├── 50-edk2-i386-secure.json
+    │       │   ├── 50-edk2-x86_64-secure.json
+    │       │   ├── 60-edk2-aarch64.json
+    │       │   ├── 60-edk2-arm.json
+    │       │   ├── 60-edk2-i386.json
+    │       │   └── 60-edk2-x86_64.json
+    │       ├── hppa-firmware.img
+    │       ├── kvmvapic.bin
+    │       ├── linuxboot.bin
+    │       ├── linuxboot_dma.bin
+    │       ├── multiboot_dma.bin
+    │       ├── pvh.bin
+    │       ├── qboot.rom
+    │       ├── qemu-nsis.bmp
+    │       ├── s390-ccw.img
+    │       ├── s390-netboot.img
+    │       ├── vof.bin
+    │       └── vof-nvram.bin
+    └── ovmf
+        ├── HYGONCSV.fd
+        └── OVMF.fd
+```
+
+### containerd配置文件中添加kata
+
+```
+vim /etc/containerd/config.toml
+```
+
+打开配置文件，末尾添加下面的内容
+
+```
+[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata]
+  cri_handler = ""
+  runtime_type = "io.containerd.kata.v2"
+  privileged_without_host_devices = true
+  pod_annotations = ["io.katacontainers.*"]
+  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata.options]
+    ConfigPath = "/opt/confidential-containers/share/defaults/kata-containers/configuration.toml"
+[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-qemu]
+  cri_handler = "cc"
+  runtime_type = "io.containerd.kata.v2"
+  privileged_without_host_devices = true
+  pod_annotations = ["io.katacontainers.*"]
+  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-qemu.options]
+    ConfigPath = "/opt/confidential-containers/share/defaults/kata-containers/configuration-qemu.toml"
+[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-qemu-csv]
+  cri_handler = "cc"
+  runtime_type = "io.containerd.kata.v2"
+  privileged_without_host_devices = true
+  pod_annotations = ["io.katacontainers.*"]
+  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata-qemu-csv.options]
+    ConfigPath = "/opt/confidential-containers/share/defaults/kata-containers/configuration-qemu-csv.toml"
+```
+
+### 重启containerd
+
+```
+sudo systemctl daemon-reload
+sudo systemctl restart containerd
+```
+
+### 为k8s创建对应的RuntimeClass
+
+```
+cat <<-EOF | kubectl apply -f -
+apiVersion: node.k8s.io/v1
+kind: RuntimeClass
+metadata:
+  name: kata
+handler: kata
+EOF
+
+cat <<-EOF | kubectl apply -f -
+apiVersion: node.k8s.io/v1
+kind: RuntimeClass
+metadata:
+  name: kata-qemu
+handler: kata-qemu
+EOF
+
+cat <<-EOF | kubectl apply -f -
+apiVersion: node.k8s.io/v1
+kind: RuntimeClass
+metadata:
+  name: kata-qemu-csv
+handler: kata-qemu-csv
+EOF
+```
+
+检查创建的 RuntimeClasses。
+
+```shell
+kubectl get runtimeclass
+```
+
+预期结果如下：
+
+```shell
+NAME            HANDLER         AGE
+kata            kata            23s
+kata-qemu       kata-qemu       11s
+kata-qemu-csv   kata-qemu-csv   5s
+```
+
+### 安装simple-kbs
+
+```
+cd hygon-devkit/csv/confidential-containers/
+sudo rpm -ivh --nodeps RPMs/simple-kbs-0.5.0-1.x86_64.rpm
+```
+
+#### 导出CSV证书链
+
+Kata 机密容器需要 CSV 证书链从而与guest owner建立安全会话。CSV 证书链必须放在 /opt/csv 中，使用以下命令导出 CSV 证书链：
+
+```shell
+sudo su
+mkdir -p /opt/csv
+/opt/hygon/bin/hag csv export_cert_chain
+cat pdh.cert pek.cert oca.cert cek.cert hsk.cert hrk.cert  > /opt/csv/cert_chain.cert
+```
+
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/CC\345\234\272\346\231\257\345\246\202\344\275\225\344\270\213\350\275\275\351\234\200\350\246\201auth\347\232\204\351\225\234\345\203\217.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/CC\345\234\272\346\231\257\345\246\202\344\275\225\344\270\213\350\275\275\351\234\200\350\246\201auth\347\232\204\351\225\234\345\203\217.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f8b2230c719abf39c19c0fd7332148eceeb49b34
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/CC\345\234\272\346\231\257\345\246\202\344\275\225\344\270\213\350\275\275\351\234\200\350\246\201auth\347\232\204\351\225\234\345\203\217.md"
@@ -0,0 +1,66 @@
+# CC场景如何下载需要auth的镜像
+
+> 对于一些私人仓库，需要登录，才能下载镜像，所以需要添加账号的credential信息到kbs或initrd中。
+
+## 添加您的账号信息到docker_auth_config.json
+
+```
+# 首先获取账户名密码的base64 encode,比如：
+$ echo "pawsonfang:Passw0rd123" | base64
+cGF3c29uZmFuZzpQYXNzdzByZDEyMwo=
+```
+
+## 更新到docker_auth_config.json
+
+```
+{
+    "https://index.docker.io/v1/": {
+        "auth": "bGl1ZGFsaWJqOlBhc3N3MHJkIXFhego="
+    },
+    "quay.io": {
+        "auth": "bGl1ZGFsaWJqOlBhc3N3MHJkIXFhego="
+    },
+    "docker.io": {
+    	"auth": "cGF3c29uZmFuZzpQYXNzdzByZDEyMwo="
+    }
+}
+```
+
+## 更新信息到kbs或initrd
+
+> 对于online_sev_kbc/offline_fs_kbc，更新信息到kbs中；
+>
+> 对于offline_fs_kbc，更新信息到initrd；
+
+### online_sev_kbc/offline_fs_kbc
+
+- 获取simple-kbs的container id
+
+  ```
+  KBS_CID=$(sudo docker ps -aqf "name=^simple-kbs-server")
+  ```
+
+
+
+- 更新json文件到simple-kbs
+
+  ```
+  cd /opt/simple-kbs/resources
+  sudo docker cp docker_auth_config.json ${KBS_CID}:/usr/local/bin/resources/docker_auth_config.json
+  ```
+
+
+
+### offline_fs_kbc
+
+- 解包initrd
+
+- 将新的json文件的base64更新到resource.json
+
+  ```
+  cat /path/to/docker_auth_config.json | base64 --wrap=0
+  # 把输出更新到etc/aa-offline_fs_kbc-resources.json的default/credential/test字段
+  ```
+
+- 打包initrd
+
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\344\275\277\347\224\250offline_fs_kbc\346\250\241\345\274\217\350\277\220\350\241\214\347\255\276\345\220\215\345\256\271\345\231\250.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\344\275\277\347\224\250offline_fs_kbc\346\250\241\345\274\217\350\277\220\350\241\214\347\255\276\345\220\215\345\256\271\345\231\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..140a688a257844cbe68646dfd0908fdd99f6a5e2
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\344\275\277\347\224\250offline_fs_kbc\346\250\241\345\274\217\350\277\220\350\241\214\347\255\276\345\220\215\345\256\271\345\231\250.md"
@@ -0,0 +1,48 @@
+# 使用offline_fs_kbc模式运行签名容器.md
+
+> offline_fs_kbc模式，是把验签公钥放在initrd中，不需要借助于simple-kbs，相应的，也就不支持pre_attestation
+
+- 编辑kata配置文件(kata 的配置文件路径：/opt/confidential-containers/share/defaults/kata-containers/configuration-qemu-csv.toml。)
+
+设置kbc_mode，initrd指向offline_fs_kbc模式的initrd，关闭pre_attestation功能，使能镜像验签功能：
+
+```
+initrd = "/opt/confidential-containers/share/kata-containers/kata-ubuntu-20.04-csv-offline_fs_kbc.initrd"
+guest_pre_attestation = false
+kernel_params = "agent.aa_kbc_params=offline_fs_kbc::null agent.enable_signature_verification=true "
+```
+
+- 启动 Pod
+
+```shell
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    run: test-sign-offline
+  name: test-sign-offline
+spec:
+  containers:
+  - image: docker.io/pawsonfang/mybusybox
+    name: test-sign-offline
+    imagePullPolicy: Always
+  dnsPolicy: ClusterFirst
+  restartPolicy: Never
+  runtimeClassName: kata-qemu-csv
+EOF
+```
+
+- 查看 pod 是否启动成功：
+
+```shell
+kubectl get pods
+```
+
+- 预期结果如下：
+
+```shell
+NAME                READY   STATUS    RESTARTS   AGE
+test-sign-offline     1/1     Running   0          31h
+```
+
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\344\275\277\347\224\250offline_sev_kbc\346\250\241\345\274\217\350\277\220\350\241\214\345\212\240\345\257\206\345\256\271\345\231\250.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\344\275\277\347\224\250offline_sev_kbc\346\250\241\345\274\217\350\277\220\350\241\214\345\212\240\345\257\206\345\256\271\345\231\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..fe6a2822d4515c154b3efe10b7a3b1a2c2a1869f
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\344\275\277\347\224\250offline_sev_kbc\346\250\241\345\274\217\350\277\220\350\241\214\345\212\240\345\257\206\345\256\271\345\231\250.md"
@@ -0,0 +1,45 @@
+# 使用offline_sev_kbc模式运行加密容器.md
+
+- kata配置文件默认配置为online模式，请修改为下面的字段，使其为offline模式：
+
+  ```
+  initrd = "/opt/confidential-containers/share/kata-containers/kata-ubuntu-20.04-csv-offline_sev_kbc.initrd"
+  guest_pre_attestation_kbs_mode="offline"
+  ```
+
+- 自定义 policy ，请参考[自定义simple-kbs的policy](./自定义simple-kbs的policy.md)。
+
+
+- 启动 Pod
+
+```shell
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    run: test-en-offline
+  name: test-en-offline
+spec:
+  containers:
+  - image: docker.io/pawsonfang/busybox:encrypted
+    name: test-en-offline
+    imagePullPolicy: Always
+  dnsPolicy: ClusterFirst
+  restartPolicy: Never
+  runtimeClassName: kata-qemu-csv
+EOF
+```
+
+- 查看 pod 是否启动成功：
+
+```shell
+kubectl get po
+```
+
+- 预期结果如下：
+
+```shell
+NAME                READY   STATUS    RESTARTS   AGE
+test-en-offline     1/1     Running   0          31h
+```
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\345\210\266\344\275\234\344\270\200\344\270\252\346\226\260\347\232\204\345\212\240\345\257\206\351\225\234\345\203\217\345\271\266\351\203\250\347\275\262.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\345\210\266\344\275\234\344\270\200\344\270\252\346\226\260\347\232\204\345\212\240\345\257\206\351\225\234\345\203\217\345\271\266\351\203\250\347\275\262.md"
new file mode 100644
index 0000000000000000000000000000000000000000..8d0139a512cea19ead1aad672d41948bbf3b7d3f
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\345\210\266\344\275\234\344\270\200\344\270\252\346\226\260\347\232\204\345\212\240\345\257\206\351\225\234\345\203\217\345\271\266\351\203\250\347\275\262.md"
@@ -0,0 +1,193 @@
+# 制作一个新的加密镜像并部署
+
+本文主要为您介绍如何制作一个新的加密镜像，并部署pod。
+
+#### 安装依赖
+
+需要借助[skopeo](https://github.com/containers/skopeo)加密容器镜像，安装步骤如下：
+
+```
+# 安装go，用于编译
+sudo yum install go -y
+# 安装git、make等依赖
+sudo yum install git make gcc gpgme-devel libassuan-devel device-mapper-devel -y
+# 源码安装skopeo
+git clone https://github.com/containers/skopeo $(go env GOPATH)/src/github.com/containers/skopeo
+cd $(go env GOPATH)/src/github.com/containers/skopeo
+DISABLE_DOCS=1 make bin/skopeo
+sudo DISABLE_DOCS=1 make install
+# 检查命令可用
+skopeo -v
+```
+
+#### 加密镜像
+
+Attestation Agent可以启动一个grpc服务来支持对映像进行加密。克隆仓库:
+
+```
+attestation_agent_tag="v0.5.0"
+git clone https://github.com/confidential-containers/attestation-agent.git
+(cd attestation-agent && git checkout -b "branch_${attestation_agent_tag}" "${attestation_agent_tag}")
+```
+
+编译并启动CoCo Keyprovider:
+
+```
+# 安装依赖
+curl https://sh.rustup.rs -sSf | sh
+source "$HOME/.cargo/env"
+sudo yum install openssl-devel -y
+# 编译并启动
+cd attestation-agent/coco_keyprovider
+RUST_LOG=coco_keyprovider cargo run --release -- --socket 127.0.0.1:50000
+```
+
+创建 Attestation Agent keyprovider:
+
+```
+cat > ocicrypt.conf <<EOF
+{
+  "key-providers": {
+    "attestation-agent": {
+      "grpc": "127.0.0.1:50000"
+}}}
+EOF
+```
+
+产生一个32-bytes的值作为加密密钥
+
+```
+head -c32 < /dev/random > key1
+```
+
+把你想要加密的镜像加密并拷贝到当前目录，本例中使用的是`busybox`镜像。其中密钥使用`keypath`指定，`keyid`此处设置为`kbs:///default/key/key_id2`，密钥算法设置为`A256GCM`，`——insecure-policy`标志用于连接到认证代理，不会影响项目的安全性。
+
+```
+OCICRYPT_KEYPROVIDER_CONFIG=ocicrypt.conf skopeo copy --insecure-policy --encryption-key provider:attestation-agent:keypath=$(pwd)/key1::keyid=kbs:///default/key/key_id2::algorithm=A256GCM docker://busybox oci:busybox:encrypted
+```
+
+加密后，可以看到在当前目录下生成了`busybox`目录。
+
+确认镜像确实已经被加密：
+
+```
+cat ./busybox/index.json | python3 -m json.tool
+```
+
+xxxxxxxxxx NAME                READY   STATUS    RESTARTS   AGEtest-en-offline     1/1     Running   0          31hshell
+
+```
+{
+    "schemaVersion": 2,
+    "manifests": [
+        {
+            "mediaType": "application/vnd.oci.image.manifest.v1+json",
+            "digest": "sha256:f594fcb13ca12e4ebf400b5e8ab715cb4f30adb335b8e31366d61f5350029e6e",
+            "size": 1195,
+            "annotations": {
+                "org.opencontainers.image.ref.name": "encrypted"
+            }
+        }
+    ]
+}
+```
+
+根据digest找到对应的manifest：`./busybox/blocs/sha256/73135775766027c5006e7744fa8007e812afec905064743c68b780dd49c1eeaf`
+
+```
+cat ./busybox/blobs/sha256/f594fcb13ca12e4ebf400b5e8ab715cb4f30adb335b8e31366d61f5350029e6e | python3 -m json.tool
+```
+
+期望结果：
+
+```
+{
+    "schemaVersion": 2,
+    "mediaType": "application/vnd.oci.image.manifest.v1+json",
+    "config": {
+        "mediaType": "application/vnd.oci.image.config.v1+json",
+        "digest": "sha256:3488e6e2e41e62fc51be840cd61d806d5b45defdb84a2e6c99ea8a0edb4b6cc7",
+        "size": 575
+    },
+    "layers": [
+        {
+            "mediaType": "application/vnd.oci.image.layer.v1.tar+gzip+encrypted",
+            "digest": "sha256:0dfdc90a4529ca0b38e575945748d6f8258ad2ea2cce8755b8a9f0e1566e447f",
+            "size": 2592227,
+            "annotations": {
+                "org.opencontainers.image.enc.keys.provider.attestation-agent": "eyJraWQiOiJrYnM6Ly8vZGVmYXVsdC90ZXN0LWtleS8xIiwid3JhcHBlZF9kYXRhIjoiLzNMeWhsdVE1aG42MVVjN0ZDM1BWTlNDUlV0YitLc1h5ZWhGTERtaUJlcUE4cStrcGgxbFpwckR4cjh0ck5RUFpxRDB2UlFobVFFWTM1YnV3R05VeGRINXdyeWtCa0x2OTFkSHFHMEJOY1FETVNhNTBBZFpqb00xTHQ0SUdIUDlZeEpGL3hmcWk4RFFBUmdXNjhpV3hlcWgxTFRMQ01hcUg5TzUxeXduYmcxTmJ3aFM0aXdkRSttMGRhOWwyTXpqeklrbjRtN3pWZUl6cFRVVHJuS0gyM1RmWmVWZUZsZVMxY0VscWhGdGw4bnZDYmphNlZyQlFYTzRFVVZUdjkvemxzS2xnRnl3aEhnL1VvUHBmMXMvY2RJPSIsIml2IjoiQUFBQUFBQUFBQUFBQUFBQSIsIndyYXBfdHlwZSI6IkEyNTZHQ00ifQ==",
+                "org.opencontainers.image.enc.pubopts": "eyJjaXBoZXIiOiJBRVNfMjU2X0NUUl9ITUFDX1NIQTI1NiIsImhtYWMiOiJqWHhYMGVWWGR2RHAxbVpxSHVXYzFJWGFwazhicmhKMHdpbDl5K3JLUXc4PSIsImNpcGhlcm9wdGlvbnMiOnt9fQ=="
+            }
+        }
+    ]
+}
+```
+
+其中`mediaType`为`application/vnd.oci.image.layer.v1.tar+gzip+encrypted`，表示该layer已被加密。
+
+#### 上传镜像到远程的image registry
+
+记得把docker.io/myrepo替换为自己的仓库地址：
+
+```
+# 登录您的image registry，比如登录docker.io
+skopeo login docker.io
+# 上传镜像
+skopeo copy --insecure-policy oci:busybox:encrypted docker://docker.io/myrepo/busybox:encrypted
+```
+
+#### 更新密钥到kbs
+
+- 设置数据库参数
+
+  ```
+  KBS_DB_USER="kbsuser"
+  KBS_DB_PW="kbspassword"
+  KBS_DB="simple_kbs"
+  KBS_DB_TYPE="mysql"
+  KBS_DB_HOST=$(sudo docker network inspect simple-kbs_default \
+    | jq -r '.[].Containers[] | select(.Name | test("simple-kbs[_-]db.*")).IPv4Address' \
+    | sed "s|/.*$||g")
+  ```
+
+- 获取加密密钥的base64 encode
+
+```shell
+enc_key=$(cat key1 | base64)
+echo $enc_key
+```
+
+- 将 加密密钥 注入 mysql 中。
+
+```shell
+mysql -u${KBS_DB_USER} -p${KBS_DB_PW} -h ${KBS_DB_HOST} -D ${KBS_DB} <<EOF
+  REPLACE INTO secrets VALUES (11, 'default/key/key_id2', '${enc_key}', 10);
+  REPLACE INTO keysets VALUES (11, 'KEYSET-2', '["default/key/key_id2"]', 10);
+EOF
+```
+
+> 注意：`default/key/key_id2`要与skopeo参数相同；使用offline_sev_kbc时，要设置`configuration-qemu-csv.toml`中`guest_pre_attestation_keyset`的值为`KEYSET-2`
+
+#### 使用新的加密镜像启动pod
+
+> myrepo替换为自己的仓库地址
+
+```
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    run: test-en-online2
+  name: test-en-online2
+spec:
+  containers:
+  - image: docker.io/myrepo/busybox:encrypted
+    name: test-en-online2
+    imagePullPolicy: Always
+  dnsPolicy: ClusterFirst
+  restartPolicy: Never
+  runtimeClassName: kata-qemu-csv
+EOF
+```
+
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\345\210\266\344\275\234\344\270\200\344\270\252\346\226\260\347\232\204\347\255\276\345\220\215\351\225\234\345\203\217\345\271\266\351\203\250\347\275\262.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\345\210\266\344\275\234\344\270\200\344\270\252\346\226\260\347\232\204\347\255\276\345\220\215\351\225\234\345\203\217\345\271\266\351\203\250\347\275\262.md"
new file mode 100644
index 0000000000000000000000000000000000000000..195b4afd74889e673c0a64679a6b73b73a7ae43a
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\345\210\266\344\275\234\344\270\200\344\270\252\346\226\260\347\232\204\347\255\276\345\220\215\351\225\234\345\203\217\345\271\266\351\203\250\347\275\262.md"
@@ -0,0 +1,161 @@
+# 制作一个新的签名镜像并部署
+
+本文主要为您介绍如何制作一个新的签名镜像，并部署pod。
+
+## 安装cosign
+
+```
+git clone https://github.com/sigstore/cosign
+cd cosign
+go install ./cmd/cosign
+$(go env GOPATH)/bin/cosign
+```
+
+## 准备镜像
+
+> 示例中使用docker.io存放签名镜像
+
+```
+# 使用自己的账号、密码登录
+sudo docker login
+# 以busybox为例
+sudo docker pull busybox
+# YOUR_USER替换为自己的用户名，YOUR_IMAGE替换为自己想要命名的image name
+sudo docker image tag busybox docker.io/YOUR_USER/YOUR_IMAGE
+sudo docker push docker.io/YOUR_USER/YOUR_IMAGE
+```
+
+## 使用cosign签名镜像
+
+```
+$(go env GOPATH)/bin/cosign generate-key-pair
+# 输入密码，密码是用来加密私钥的
+$(go env GOPATH)/bin/cosign login docker.io --username YOUR_USER
+sudo $(go env GOPATH)/bin/cosign sign --key cosign.key docker.io/YOUR_USER/YOUR_IMAGE
+```
+
+## 自定义policy.json
+
+> 创建一个新的policy.json，自定义image的pull规则，如下面示例所示，注意keyPath对应的位置用于索引公钥。
+
+```
+{
+    "default": [{"type": "insecureAcceptAnything"}], 
+    "transports": {
+        "docker": {
+            "docker.io/pawsonfang/mybusybox": [
+                {
+                    "type": "sigstoreSigned",
+                    "keyPath": "kbs:///default/cosign-public-key/test"
+                }
+            ],
+            "docker.io/pawsonfang/busybox_signed": [
+                {
+                    "type": "sigstoreSigned",
+                    "keyPath": "kbs:///default/cosign-public-key/test2"
+                }
+            ]
+        }
+    }
+}
+```
+
+## 根据kbc_mod更新公钥和policy
+
+> 对于online_sev_kbc，将公钥和policy添加到数据库；
+>
+> 对于offline_fs_kbc，将公钥和policy更新到initrd中。
+
+### online_sev_kbc
+
+- 获取simple-kbs的container id
+
+  ```
+  KBS_CID=$(sudo docker ps -aqf "name=^simple-kbs-server")
+  ```
+
+
+
+- 更新policy文件和公钥文件到simple-kbs
+
+  ```
+  cd /opt/simple-kbs/resources
+  sudo docker cp /path/to/policy.json ${KBS_CID}:/usr/local/bin/resources/image_pull_policy.json
+  sudo docker cp /path/to/cosign.pub ${KBS_CID}:/usr/local/bin/resources/cosign2.pub
+  ```
+
+- 设置数据库参数
+
+  ```
+  KBS_DB_USER="kbsuser"
+  KBS_DB_PW="kbspassword"
+  KBS_DB="simple_kbs"
+  KBS_DB_TYPE="mysql"
+  KBS_DB_HOST=$(sudo docker network inspect simple-kbs_default \
+    | jq -r '.[].Containers[] | select(.Name | test("simple-kbs[_-]db.*")).IPv4Address' \
+    | sed "s|/.*$||g")
+  ```
+
+  插入新的公钥keyid:resource_path信息到数据库中
+
+  ```
+  mysql -u${KBS_DB_USER} -p${KBS_DB_PW} -h ${KBS_DB_HOST} -D ${KBS_DB} <<EOF
+    REPLACE INTO resources VALUES(11, "unused4","default/cosign-public-key/test2","cosign2.pub",NULL);
+  EOF
+  ```
+
+### offline_fs_kbc
+
+- 解压initrd image
+
+```
+cp /opt/confidential-containers/share/kata-containers/kata-ubuntu-20.04-csv-offline_fs_kbc.initrd ./initrd.img.gz
+gunzip initrd.img.gz
+mkdir initrd
+cd initrd/
+cpio -ivmd < ../initrd.img
+```
+
+- 将policy和公钥更新到resource.json
+
+```
+cat /path/to/policy.json | base64 --wrap=0
+# 把policy更新到initrd/etc/aa-offline_fs_kbc-resources.json中"default/security-policy/test"字段。
+cat /path/to/cosign.pub | base64 --wrap=0
+# 把对应的keyPath和公钥作为键值对，添加到initrd/etc/aa-offline_fs_kbc-resources.json，类似如下：
+"default/cosign-public-key/test2": "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUZrd0V3WUhLb1pJemowQ0FRWUlLb1pJemowREFRY0RRZ0FFdkJLNUhlTUo1MDkzcEppR0xBQlFCTUprSEQ5SgozeHZGT0p4WW9BY2pNNDlHa3ZVcW1hb0Q1dXdjRFhlSW9CL3Ric1I4enRnN2ZINE5ISlhud2oyTzFnPT0KLS0tLS1FTkQgUFVCTElDIEtFWS0tLS0tCg==",
+```
+
+- 打包initrd
+
+```sh
+cd initrd/
+find . | cpio -o -H newc > ../initrd.new.img
+gzip ../initrd.new.img
+cd ../ && mv initrd.new.img.gz initrd.new.img
+cp initrd.new.img /opt/confidential-containers/share/kata-containers/kata-ubuntu-20.04-csv-offline_fs_kbc.initrd
+```
+
+#### 使用新的image启动pod，此处以online_sev_kbc为例
+
+> YOUR_USER/YOUR_IMAGE替换为自己的镜像地址
+
+```
+cat <<-EOF | kubectl apply -f -
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    run: test-sign-online2
+  name: test-sign-online2
+spec:
+  containers:
+  - image: docker.io/YOUR_USER/YOUR_IMAGE
+    name: test-sign-online2
+    imagePullPolicy: Always
+  dnsPolicy: ClusterFirst
+  restartPolicy: Never
+  runtimeClassName: kata-qemu-csv
+EOF
+```
+
diff --git "a/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\350\207\252\345\256\232\344\271\211simple-kbs\347\232\204policy.md" "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\350\207\252\345\256\232\344\271\211simple-kbs\347\232\204policy.md"
new file mode 100644
index 0000000000000000000000000000000000000000..def57a8ff53153a0ded5ec4d624973073b511793
--- /dev/null
+++ "b/DEVELOPER_DOCS/\346\265\267\345\205\211\345\256\211\345\205\250\350\231\232\346\213\237\345\214\226\346\212\200\346\234\257CSV/CSV\346\234\272\345\257\206\345\256\271\345\231\250-0.5.0/\350\207\252\345\256\232\344\271\211simple-kbs\347\232\204policy.md"
@@ -0,0 +1,83 @@
+# 自定义simple KBS 的policy
+
+- /opt/confidential-containers/bin/csv-measure.py是一个实用程序，用于使用提供的 ovmf、initrd、kernel、cmdline等作为参数来计算 CSV guest固件测量值。
+
+- 计算内核的append值（需要先启动一个offline_sev_kbc或online_sev_kbc的pod）
+
+```shell
+duration=$((SECONDS+30))
+set append
+
+while [ $SECONDS -lt $duration ]; do
+  qemu_process=$(ps aux | grep qemu | grep append || true)
+  if [ -n "${qemu_process}" ]; then
+    append=$(echo ${qemu_process} \
+      | sed "s|.*-append \(.*$\)|\1|g" \
+      | sed "s| -.*$||")
+    break
+  fi
+  sleep 1
+done
+
+echo "${append}" > cmdline_file
+```
+
+- 根据ovmf、kernel、initrd_path和cmdline_file的地址设置参数。
+    - ovmf、kernel和initrd_path的地址请参考kata 的配置文件
+    - kata 的配置文件路径：/opt/confidential-containers/share/defaults/kata-containers/configuration-qemu-csv.toml。
+
+```shell
+ovmf_path="/opt/confidential-containers/share/ovmf/HYGONCSV.fd"
+kernel_path="/opt/confidential-containers/share/kata-containers/vmlinuz-csv.container"
+initrd_path="/opt/confidential-containers/share/kata-containers/kata-ubuntu-20.04-csv-online_sev_kbc.initrd"
+cmdline_path=${PWD}/cmdline_file
+```
+
+- 使用csv-measure.py 来计算 CSV guest 的Launch digest。
+
+```shell
+ #安装依赖
+ sudo pip3 install snowland-smx
+ #计算digest
+ measurement=$(/opt/confidential-containers/bin/csv-measure.py \
+  --ovmf "${ovmf_path}" \
+  --kernel "${kernel_path}" \
+  --initrd "${initrd_path}" \
+  --cmdline "${cmdline_path}" \
+)
+# 确认measurement计算成功
+echo $measurement
+```
+
+- 设置simple kbs 数据库参数
+
+```shell
+KBS_DB_USER="kbsuser"
+KBS_DB_PW="kbspassword"
+KBS_DB="simple_kbs"
+KBS_DB_TYPE="mysql"
+KBS_DB_HOST=$(sudo docker network inspect simple-kbs_default \
+  | jq -r '.[].Containers[] | select(.Name | test("simple-kbs[_-]db.*")).IPv4Address' \
+  | sed "s|/.*$||g")
+```
+
+- 由于本文使用的加密镜像( docker.io/pawsonfang/busybox:encrypted )，是采用 simple kbs 已经存在的密钥来解密，该镜像的 enc_key 值如下。用户需要根据加密镜像按需设置enc_key。
+
+```shell
+enc_key=C1z522QYM9YZDcz+7nstjYD2HNX1/2/okVStRA2ChDo=
+```
+
+- 将 自定义policy 注入 mysql 中。
+    - policy的组成包括：digests、policies、api_major、api_minor、build_ids等信息。详情请参考[链接](https://github.com/confidential-containers/simple-kbs/blob/main/db/db-mysql.sql#L73)。
+    - 我们以digests为例子，向用户展示如何注入自定义policy 。用户可以根据需求自定义Policy。
+
+```shell
+# 安装依赖
+yum install mysql -y
+mysql -u${KBS_DB_USER} -p${KBS_DB_PW} -h ${KBS_DB_HOST} -D ${KBS_DB} <<EOF
+  REPLACE INTO secrets VALUES (10, 'default/key/key_id1', '${enc_key}', 10);
+  REPLACE INTO keysets VALUES (10, 'KEYSET-1', '["default/key/key_id1"]', 10);
+  REPLACE INTO policy VALUES (10, '["${measurement}"]', '[]', 0, 0, '[]', now(), NULL, 1);
+EOF
+```
+
diff --git a/PRODUCT_DOCS/menu.yaml b/PRODUCT_DOCS/menu.yaml
index 6602b4569d5a5e84a9c740d634e6ec99b84653a8..51bb07caaf12cb9408352f571b3e78725fb1efc2 100644
--- a/PRODUCT_DOCS/menu.yaml
+++ b/PRODUCT_DOCS/menu.yaml
@@ -1,4 +1,4 @@
-DEVELOPER_DOCS:
+PRODUCT_DOCS:
   menu: menu.yml
   maintainers: maintainers.yml
   anolisos: