Elastic Compute Service:Terapkan CoCo pada bare metal Alibaba Cloud

Langkah 1: Buat instans bare metal TDX

Buat instans bare metal Alibaba Cloud generasi ke-8 yang mendukung Intel TDX.

1. Buka halaman pembelian instans.

2. Pilih metode penagihan, wilayah, dan zona ketersediaan. Gambar komunitas yang diperlukan hanya tersedia di zona tertentu. Untuk contoh ini, pilih Beijing Zone I.

3. Pada bagian Instance, klik Elastic Bare Metal Server dan pilih tipe instans ecs.ebmg8i.48xlarge.

4. Pada bagian Image, pilih Community Image dan cari ID gambar m-2ze2ucup4c5bvgx751lx. Centang kotak Confidential VM untuk mengaktifkan TDX.

   Penting

   Ini adalah gambar kustom berbasis Ubuntu dengan driver TDX yang telah dipra-instal. Pengguna SSH default adalah ubuntu, bukan root.

5. Konfigurasikan jaringan, penyimpanan, bandwidth, security group, dan pengaturan manajemen. Lihat Deskripsi Item Konfigurasi.

6. Tinjau konfigurasi keseluruhan di sisi kanan halaman. Atur opsi seperti durasi langganan dan pastikan semua pengaturan sesuai kebutuhan Anda.

7. Klik Confirm Order untuk membuat instans.

   Pembuatan instans memerlukan waktu 3 hingga 5 menit. Buka halaman Instances di Konsol untuk memeriksa statusnya. Instans siap digunakan ketika statusnya berubah menjadi Running.

Langkah 2: Siapkan node Kubernetes

Sambungkan ke instans dan instal perangkat lunak yang diperlukan untuk mengonfigurasinya sebagai kluster Kubernetes single-node.

1. Instal containerd

   # Perbarui sumber paket dan instal dependensi.
   sudo apt-get update
   sudo apt-get install -y ca-certificates curl
   
   # Tambahkan kunci GPG resmi Docker.
   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
   
   # Tambahkan repositori APT Docker.
   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
     
   # Instal containerd.
   sudo apt-get update
   sudo apt-get install -y containerd.io

2. Konfigurasikan containerd Hasilkan file konfigurasi default dan modifikasi parameter utama agar kompatibel dengan Kubernetes.

   # Hasilkan file konfigurasi default.
   sudo mkdir -p /etc/containerd
   containerd config default | sudo tee /etc/containerd/config.toml
   
   # Ganti registri citra Kubernetes dengan mirror Alibaba Cloud untuk mempercepat pengambilan citra.
   sudo sed -i -E 's#registry.k8s.io#registry.aliyuncs.com/google_containers#g' /etc/containerd/config.toml
   
   # Ubah driver cgroup ke systemd agar memenuhi persyaratan Kubernetes.
   sudo sed -i 's#SystemdCgroup = false#SystemdCgroup = true#g' /etc/containerd/config.toml
   
   # Restart layanan containerd untuk menerapkan perubahan.
   sudo systemctl restart containerd

3. Konfigurasikan parameter kernel Nonaktifkan partisi swap dan muat modul kernel yang diperlukan untuk jaringan dan runtime Kubernetes.

   # Nonaktifkan swap sementara.
   sudo swapoff -a
   # Nonaktifkan swap secara permanen dengan mengomentari entri swap di file fstab.
   sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
   
   # Muat modul kernel overlay dan br_netfilter.
   sudo modprobe overlay
   sudo modprobe br_netfilter
   
   # Konfigurasikan modul agar dimuat otomatis saat boot.
   sudo tee /etc/modules-load.d/k8s.conf <<EOF
   overlay
   br_netfilter
   EOF
   
   # Konfigurasikan parameter kernel untuk mengizinkan IP forwarding dan pemrosesan trafik bridged.
   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
   
   # Terapkan semua konfigurasi sysctl.
   sudo sysctl --system

Langkah 3: Instal kluster Kubernetes single-node

Gunakan kubeadm untuk menyiapkan kluster Kubernetes single-node.

1. Instal komponen Kubernetes Instal kubeadm, kubelet, dan kubectl.

   # Tambahkan kunci GPG untuk repositori APT Kubernetes.
   curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
   
   # Tambahkan repositori APT Kubernetes.
   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
   
   # Instal alat Kubernetes.
   sudo apt-get update
   sudo apt-get install -y kubectl kubeadm kubelet
   sudo apt-mark hold kubelet kubeadm kubectl

2. Inisialisasi lapisan kontrol Gunakan kubeadm init untuk menginisialisasi lapisan kontrol.

   # Dapatkan alamat IP antarmuka jaringan utama untuk digunakan sebagai alamat advertise API server.
   # Catatan: Perintah ini mengasumsikan antarmuka utama adalah eth0. Jika lingkungan Anda berbeda, gantilah dengan alamat IP yang benar.
   NODE_IP=$(ip -o -4 addr show dev eth0 | awk '{split($4,a,"/");print a[1]}')
   
   # Inisialisasi kluster.
   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

   Setelah inisialisasi, ikuti instruksi output untuk mengonfigurasi kredensial akses 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. Instal plugin jaringan Terapkan plugin CNI Flannel untuk komunikasi antar-Pod.

   # Instal plugin jaringan Flannel.
   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
   
   # Modifikasi manifes Flannel untuk mengatur CIDR jaringan Pod yang benar dan menggunakan mirror citra regional.
   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
   
   # Terapkan Flannel.
   kubectl apply -f kube-flannel.yml

4. Hapus taint lapisan kontrol Izinkan beban kerja pada kluster single-node ini dengan menghapus taint NoSchedule dari node bidang kontrol.

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

Langkah 4: Terapkan komponen CoCo

Pilih metode Helm chart atau Operator untuk menerapkan 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

# Izinkan node saat ini bertindak sebagai 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

Langkah 5: Terapkan dan verifikasi Pod contoh

Jalankan Pod contoh dan verifikasi bahwa Pod tersebut berjalan di dalam VM rahasia TDX.

1. Beri label pada node Beri label pada node worker untuk menunjukkan dukungan runtime Kata.

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

2. Terapkan Pod contoh Buat Pod yang menggunakan runtime TDX melalui runtimeClassName dalam spec-nya.

   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. Verifikasi penerapan Pastikan Pod berjalan dengan kelas runtime yang benar.

   # Tunggu hingga status Pod menjadi Running.
   kubectl get pod coco-demo-pod
   
   # Deskripsikan Pod dan pastikan bidang "Runtime Class" bernilai "kata-qemu-tdx".
   kubectl describe pod coco-demo-pod | grep "Runtime Class"

4. Verifikasi aktivasi TDX Periksa log kernel pada instans bare metal untuk mengonfirmasi inisialisasi TDX.

   # Jalankan perintah ini pada node.
   dmesg | grep -i tdx

   Output yang berisi TDX module initialized atau pesan serupa mengonfirmasi bahwa lingkungan TDX aktif dan runtime Kata menggunakannya untuk VM rahasia.