Elastic Compute Service:Déployer CoCo sur du matériel nu Alibaba Cloud

Étape 1 : Créer une instance de matériel nu TDX

Créez une instance de matériel nu Alibaba Cloud de 8e génération prenant en charge Intel TDX.

1. Accédez à la page d'achat d'instance.

2. Sélectionnez une méthode de facturation, une région et une zone de disponibilité. L'image communautaire requise n'est disponible que dans certaines zones. Pour cet exemple, sélectionnez Beijing Zone I.

3. Dans la section Instance, cliquez sur Elastic Bare Metal Server et sélectionnez le type d'instance ecs.ebmg8i.48xlarge.

4. Dans la section Image, sélectionnez Community Image et recherchez l'ID d'image m-2ze2ucup4c5bvgx751lx. Cochez la case Confidential VM pour activer TDX.

   Important

   Il s'agit d'une image personnalisée basée sur Ubuntu avec des pilotes TDX préinstallés. L'utilisateur SSH par défaut est ubuntu, et non root.

5. Configurez les paramètres réseau, de stockage, de bande passante, de groupe de sécurité et de gestion. Consultez les Descriptions des éléments de configuration.

6. Vérifiez la configuration globale sur le côté droit de la page. Configurez les options telles que la durée de l'abonnement et assurez-vous que tous les paramètres répondent à vos besoins.

7. Cliquez sur Confirm Order pour créer l'instance.

   La création de l'instance prend de 3 à 5 minutes. Accédez à la page Instances dans la console pour vérifier l'état. L'instance est prête lorsque son statut passe à Running.

Étape 2 : Préparer le nœud Kubernetes

Connectez-vous à l'instance et installez les logiciels requis pour la configurer en tant que cluster Kubernetes mono-nœud.

1. Installer containerd

   # Update the package sources and install dependencies.
   sudo apt-get update
   sudo apt-get install -y ca-certificates curl
   
   # Add Docker's official GPG key.
   sudo install -m 0755 -d /etc/apt/keyrings
   curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
   sudo chmod a+r /etc/apt/keyrings/docker.asc
   
   # Add Docker's APT repository.
   echo \
     "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
     $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
     sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
     
   # Install containerd.
   sudo apt-get update
   sudo apt-get install -y containerd.io

2. Configurer containerd Générez le fichier de configuration par défaut et modifiez les paramètres clés pour assurer la compatibilité avec Kubernetes.

   # Generate the default configuration file.
   sudo mkdir -p /etc/containerd
   containerd config default | sudo tee /etc/containerd/config.toml
   
   # Replace the Kubernetes image registry with an Alibaba Cloud mirror to accelerate image pulls.
   sudo sed -i -E 's#registry.k8s.io#registry.aliyuncs.com/google_containers#g' /etc/containerd/config.toml
   
   # Change the cgroup driver to systemd to meet Kubernetes requirements.
   sudo sed -i 's#SystemdCgroup = false#SystemdCgroup = true#g' /etc/containerd/config.toml
   
   # Restart the containerd service to apply the changes.
   sudo systemctl restart containerd

3. Configurer les paramètres du noyau Désactivez la partition swap et chargez les modules du noyau requis pour le réseau et l'exécution de Kubernetes.

   # Temporarily disable swap.
   sudo swapoff -a
   # Permanently disable swap by commenting out the swap entry in the fstab file.
   sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
   
   # Load the overlay and br_netfilter kernel modules.
   sudo modprobe overlay
   sudo modprobe br_netfilter
   
   # Configure the modules to load automatically at boot.
   sudo tee /etc/modules-load.d/k8s.conf <<EOF
   overlay
   br_netfilter
   EOF
   
   # Configure kernel parameters to allow IP forwarding and bridged traffic processing.
   sudo tee /etc/sysctl.d/kubernetes.conf <<EOT
   net.bridge.bridge-nf-call-ip6tables = 1
   net.bridge.bridge-nf-call-iptables = 1
   net.ipv4.ip_forward = 1
   EOT
   
   # Apply all sysctl configurations.
   sudo sysctl --system

Étape 3 : Installer un cluster Kubernetes mono-nœud

Utilisez kubeadm pour configurer un cluster Kubernetes mono-nœud.

1. Installer les composants Kubernetes Installez kubeadm, kubelet et kubectl.

   # Add the GPG key for the Kubernetes APT repository.
   curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
   
   # Add the Kubernetes APT repository.
   echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.32/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
   
   # Install the Kubernetes tools.
   sudo apt-get update
   sudo apt-get install -y kubectl kubeadm kubelet
   sudo apt-mark hold kubelet kubeadm kubectl

2. Initialiser le plan de contrôle Utilisez kubeadm init pour initialiser le plan de contrôle.

   # Get the IP address of the primary network interface to use as the API server's advertise address.
   # Note: This command assumes the primary interface is eth0. If your environment is different, replace it with the correct IP address.
   NODE_IP=$(ip -o -4 addr show dev eth0 | awk '{split($4,a,"/");print a[1]}')
   
   # Initialize the cluster.
   sudo kubeadm init --pod-network-cidr=10.10.0.0/16 \
     --apiserver-advertise-address ${NODE_IP} \
     --kubernetes-version v1.32.0 \
     --image-repository registry.aliyuncs.com/google_containers

   Après l'initialisation, suivez les instructions affichées pour configurer les identifiants d'accès kubectl.

   mkdir -p $HOME/.kube
   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
   sudo chown $(id -u):$(id -g) $HOME/.kube/config

3. Installer un plugin réseau Déployez le plugin CNI Flannel pour permettre la communication entre les pods.

   # Install the Flannel network plugin.
   export KUBECONFIG=/etc/kubernetes/admin.conf
   
   FLANNEL_VERSION=v0.27.4
   wget https://github.com/flannel-io/flannel/releases/download/${FLANNEL_VERSION}/kube-flannel.yml
   
   # Modify the Flannel manifest to set the correct pod network CIDR and use a regional image mirror.
   sed -i -E 's#([0-9]{1,3}\.){3}[0-9]{1,3}/[0-9]+#10.10.0.0/16#g' kube-flannel.yml
   sed -i -E 's#ghcr.io/flannel-io#confidential-ai-registry.cn-shanghai.cr.aliyuncs.com/product#g' kube-flannel.yml
   
   # Deploy Flannel.
   kubectl apply -f kube-flannel.yml

4. Supprimer le taint du plan de contrôle Autorisez les charges de travail sur ce cluster mono-nœud en supprimant le taint NoSchedule du nœud du plan de contrôle.

   NODE_NAME=$(kubectl get nodes -o jsonpath='{.items[0].metadata.name}')
   kubectl taint nodes $NODE_NAME node-role.kubernetes.io/control-plane-

Étape 4 : Déployer les composants CoCo

Choisissez la méthode Helm chart ou Operator pour déployer CoCo.

mkdir -p kustomize && cd kustomize

mkdir release && mkdir -p ccruntime/default

cat <<EOF > release/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- "github.com/confidential-containers/operator/config/release?ref=v0.17.0"

images:
- name: quay.io/confidential-containers/operator
  newName: registry-cn-hangzhou.ack.aliyuncs.com/dev/coco-operator
EOF

cat <<EOF > ccruntime/default/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- "github.com/confidential-containers/operator/config/samples/ccruntime/default?ref=v0.17.0"

images:
- name: quay.io/confidential-containers/reqs-payload
  newName: registry-cn-hangzhou.ack.aliyuncs.com/dev/coco-reqs-payload
- name: quay.io/kata-containers/kata-deploy-ci
  newName: registry-cn-hangzhou.ack.aliyuncs.com/dev/coco-kata-deploy-ci
- name: quay.io/kata-containers/kata-deploy
  newName: registry-cn-hangzhou.ack.aliyuncs.com/dev/coco-kata-deploy
EOF

# Allow the current node to act as a worker.
for NODE_NAME in $(kubectl get nodes -o jsonpath='{.items[*].metadata.name}'); do
  kubectl label node $NODE_NAME node.kubernetes.io/worker=
done

kubectl apply -k release
kubectl apply -k ccruntime/default

Étape 5 : Déployer et vérifier un pod d'exemple

Exécutez un pod d'exemple et vérifiez qu'il s'exécute dans une machine virtuelle confidentielle TDX.

1. Étiqueter le nœud Ajoutez une étiquette au nœud de travail pour indiquer la prise en charge de l'environnement d'exécution Kata.

   NODE_NAME=$(kubectl get nodes -o jsonpath='{.items[0].metadata.name}')
   kubectl label node $NODE_NAME katacontainers.io/kata-runtime=true

2. Déployer un pod d'exemple Créez un pod qui utilise l'environnement d'exécution TDX via runtimeClassName dans sa section spec.

   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: Pod
   metadata:
     name: coco-demo-pod
   spec:
     runtimeClassName: kata-qemu-tdx
     containers:
       - image: alibaba-cloud-linux-3-registry.cn-hangzhou.cr.aliyuncs.com/alinux3/alinux3:latest
         name: hello-alinux
         command:
           - "sleep"
           - "infinity"
   EOF

3. Vérifier le déploiement Confirmez que le pod est en cours d'exécution avec la classe d'exécution correcte.

   # Wait for the pod status to become Running.
   kubectl get pod coco-demo-pod
   
   # Describe the pod and confirm that the "Runtime Class" field is "kata-qemu-tdx".
   kubectl describe pod coco-demo-pod | grep "Runtime Class"

4. Vérifier l'activation de TDX Consultez les journaux du noyau sur l'instance de matériel nu pour confirmer l'initialisation de TDX.

   # Run this command on the node.
   dmesg | grep -i tdx

   La présence de messages tels que TDX module initialized dans la sortie confirme que l'environnement TDX est actif et que l'environnement d'exécution Kata l'utilise pour les machines virtuelles confidentielles.