Konfigurera CSI-drivrutin för Secrets Store för att aktivera NGINX-ingresskontrollant med TLS

Artikel
10/24/2023

Den här artikeln beskriver hur du skyddar en NGINX-ingresskontrollant med TLS med ett Azure Kubernetes Service-kluster (AKS) och en Azure Key Vault-instans (AKV). Mer information finns i TLS i Kubernetes.

Du kan importera det inkommande TLS-certifikatet till klustret med någon av följande metoder:

Program: Programdistributionsmanifestet deklarerar och monterar providervolymen. Endast när du distribuerar programmet görs certifikatet tillgängligt i klustret. När du tar bort programmet tas även hemligheten bort. Det här scenariot passar utvecklingsteam som ansvarar för programmets säkerhetsinfrastruktur och dess integrering med klustret.
Ingresskontrollant: Ingressdistributionen ändras för att deklarera och montera providervolymen. Hemligheten importeras när inkommande poddar skapas. Programmets poddar har ingen åtkomst till TLS-certifikatet. Det här scenariot passar scenarier där ett team (till exempel IT) hanterar och skapar infrastruktur- och nätverkskomponenter (inklusive HTTPS TLS-certifikat) och andra team hanterar programmets livscykel.

Förutsättningar

Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.
Innan du börjar kontrollerar du att din Azure CLI-version är >= 2.30.0eller installerar den senaste versionen.
Ett AKS-kluster med CSI-drivrutinen för Secrets Store konfigurerad.
En Azure Key Vault-instans.

Generera ett TLS-certifikat

Generera ett TLS-certifikat med hjälp av följande kommando.

export CERT_NAME=aks-ingress-cert
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
    -out aks-ingress-tls.crt \
    -keyout aks-ingress-tls.key \
    -subj "/CN=demo.azure.com/O=aks-ingress-tls"

Importera certifikatet till AKV

Exportera certifikatet till en PFX-fil med hjälp av följande kommando.

export AKV_NAME="[YOUR AKV NAME]"
openssl pkcs12 -export -in aks-ingress-tls.crt -inkey aks-ingress-tls.key  -out $CERT_NAME.pfx
# skip Password prompt

Importera certifikatet med kommandot az keyvault certificate import .

az keyvault certificate import --vault-name $AKV_NAME -n $CERT_NAME -f $CERT_NAME.pfx

Distribuera en SecretProviderClass

Exportera ett nytt namnområde med hjälp av följande kommando.
```
export NAMESPACE=ingress-basic
```
Skapa namnområdet med kommandot kubectl create namespace .
```
kubectl create namespace $NAMESPACE
```

Välj en metod för att tillhandahålla en åtkomstidentitet och konfigurera din SecretProviderClass YAML i enlighet med detta.

Se till att använda objectType=secret, vilket är det enda sättet att hämta den privata nyckeln och certifikatet från AKV.
Ange kubernetes.io/tls som type i avsnittet secretObjects .

Se följande exempel på hur Din SecretProviderClass kan se ut:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: azure-tls
spec:
  provider: azure
  secretObjects:                            # secretObjects defines the desired state of synced K8s secret objects
    - secretName: ingress-tls-csi
      type: kubernetes.io/tls
      data: 
        - objectName: $CERT_NAME
          key: tls.key
        - objectName: $CERT_NAME
          key: tls.crt
  parameters:
    usePodIdentity: "false"
    useVMManagedIdentity: "true"
    userAssignedIdentityID: <client id>
    keyvaultName: $AKV_NAME                 # the name of the AKV instance
    objects: |
      array:
        - |
          objectName: $CERT_NAME
          objectType: secret
    tenantId: $TENANT_ID                    # the tenant ID of the AKV instance

Använd SecretProviderClass på ditt Kubernetes-kluster med kommandot kubectl apply .
```
kubectl apply -f secretProviderClass.yaml -n $NAMESPACE
```

Distribuera ingresskontrollanten

Lägg till den officiella lagringsplatsen för inkommande diagram

Lägg till den officiella lagringsplatsen för inkommande diagram med hjälp av följande helm kommandon.
```
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
```

Konfigurera och distribuera NGINX-ingressen

Beroende på ditt scenario kan du välja att binda certifikatet till antingen programmet eller till ingresskontrollanten. Följ anvisningarna nedan enligt ditt val:

Binda certifikat till program

Binda certifikatet till programmet med hjälp av helm install kommandot . Programmets distribution refererar till CSI-drivrutinens Azure Key Vault-provider i Secrets Store.

helm install ingress-nginx/ingress-nginx --generate-name \
    --namespace $NAMESPACE \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
    --set defaultBackend.nodeSelector."kubernetes\.io/os"=linux

Binda certifikat till ingresskontrollant

Binda certifikatet till ingresskontrollanten med hjälp av helm install kommandot . Ingresskontrollantens distribution refererar till CSI-drivrutinens Azure Key Vault-provider för Secrets Store.

Kommentar

Om du inte använder Microsoft Entra poddhanterad identitet som åtkomstmetod tar du bort raden med --set controller.podLabels.aadpodidbinding=$AAD_POD_IDENTITY_NAME .
Dessutom krävs bindning av SecretProviderClass till en podd för att CSI-drivrutinen för Secrets Store ska montera den och generera Kubernetes-hemligheten. Se Synkronisera monterat innehåll med en Kubernetes-hemlighet .

helm install ingress-nginx/ingress-nginx --generate-name \
    --namespace $NAMESPACE \
    --set controller.replicaCount=2 \
    --set controller.nodeSelector."kubernetes\.io/os"=linux \
    --set defaultBackend.nodeSelector."kubernetes\.io/os"=linux \
    --set controller.service.annotations."service\.beta\.kubernetes\.io/azure-load-balancer-health-probe-request-path"=/healthz \
    --set controller.podLabels.aadpodidbinding=$AAD_POD_IDENTITY_NAME \
    -f - <<EOF
controller:
  extraVolumes:
      - name: secrets-store-inline
        csi:
          driver: secrets-store.csi.k8s.io
          readOnly: true
          volumeAttributes:
            secretProviderClass: "azure-tls"
  extraVolumeMounts:
      - name: secrets-store-inline
        mountPath: "/mnt/secrets-store"
        readOnly: true
EOF

Kontrollera att Kubernetes-hemligheten kubectl get secret skapades med kommandot .

kubectl get secret -n $NAMESPACE

NAME                                             TYPE                                  DATA   AGE
ingress-tls-csi                                  kubernetes.io/tls                     2      1m34s

Distribuera programmet

Återigen ändras anvisningarna något beroende på ditt scenario. Följ anvisningarna som motsvarar det scenario som du valde.

Distribuera programmet med hjälp av en programreferens

Skapa en fil med namnet aks-helloworld-one.yaml med följande innehåll.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld-one  
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aks-helloworld-one
  template:
    metadata:
      labels:
        app: aks-helloworld-one
    spec:
      containers:
      - name: aks-helloworld-one
        image: mcr.microsoft.com/azuredocs/aks-helloworld:v1
        ports:
        - containerPort: 80
        env:
        - name: TITLE
          value: "Welcome to Azure Kubernetes Service (AKS)"
        volumeMounts:
        - name: secrets-store-inline
          mountPath: "/mnt/secrets-store"
          readOnly: true
      volumes:
      - name: secrets-store-inline
        csi:
          driver: secrets-store.csi.k8s.io
          readOnly: true
          volumeAttributes:
            secretProviderClass: "azure-tls"
---
apiVersion: v1
kind: Service
metadata:
  name: aks-helloworld-one  
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld-one

Skapa en fil med namnet aks-helloworld-two.yaml med följande innehåll.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aks-helloworld-two  
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aks-helloworld-two
  template:
    metadata:
      labels:
        app: aks-helloworld-two
    spec:
      containers:
      - name: aks-helloworld-two
        image: mcr.microsoft.com/azuredocs/aks-helloworld:v1
        ports:
        - containerPort: 80
        env:
        - name: TITLE
          value: "AKS Ingress Demo"
        volumeMounts:
        - name: secrets-store-inline
          mountPath: "/mnt/secrets-store"
          readOnly: true
      volumes:
      - name: secrets-store-inline
        csi:
          driver: secrets-store.csi.k8s.io
          readOnly: true
          volumeAttributes:
            secretProviderClass: "azure-tls"
---
apiVersion: v1
kind: Service
metadata:
  name: aks-helloworld-two
spec:
  type: ClusterIP
  ports:
  - port: 80
  selector:
    app: aks-helloworld-two

Använd YAML-filerna i klustret med hjälp av kubectl apply kommandot .

kubectl apply -f aks-helloworld-one.yaml -n $NAMESPACE
kubectl apply -f aks-helloworld-two.yaml -n $NAMESPACE