Dapr en Azure Functions (2/N): Deploy a Kubernetes/AKS

En el capítulo anterior, vimos como usar Dapr en Azure Functions para esta misma Arquitectura de ejemplo y trabajamos y la ejecutamos localmente, pues bien, en esta ocasión continuamos, para deplegarla y ejecutarla en un cluster de Kubernetes y, en concreto, en AKS (Azure Kubernetes Services).

Realizaremos también algunos ajustes y mejoras, en lo que respecta a seguridad, añadiendo el uso de Key Vault a todos los componentes Dapr para las propiedades sensibles. Como excepción, el componente «secretstore» (secretstores.azure.keyvault) que, como podemos imaginar, tendrá que usar los secrets de Kubernetes.

Resumiendo, una aproximación completa y práctica de una architectura que podríamos considerar, porque no, real.

Prerequisitos

Partiendo del post/ejemplo anterior, veamos ahora como desplegarlo en nuestro Kubernetes/AKS, contaremos con los siguientes prerequisitos:

• Tener instalado dotnet y Azure Functions Core Tools
• Disponer de un Cluster de Kubernetes (AKS).
• Tener instalado Dapr.
• Haber iniciado Dapr en el Cluster AKS, ejecutando para ello «dapr init -k» como ya vimos en post anteriores.
• Tener instalado kubectl y tener configurado el cluster con el que trabajar: «kubectl config use-context <CONTEXT>«
• Partimos de este ejemplo de github.

Kubernetes / AKS

Una vez que tenemos todo lo necesario continuaremos con estos otros pasos:

1. Ejecutar el siguiente comando para la creación automática de un Dockerfile adecuado para el despliegue de las Azure Functions.

func init --docker-only --csharp

Lo que genera el siguiente Dockerfile:

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS installer-env

# Build requires 3.1 SDK
COPY --from=mcr.microsoft.com/dotnet/core/sdk:3.1 /usr/share/dotnet /usr/share/dotnet

COPY . /src/dotnet-function-app
RUN cd /src/dotnet-function-app && \
    mkdir -p /home/site/wwwroot && \
    dotnet publish *.csproj --output /home/site/wwwroot

# To enable ssh & remote debugging on app service change the base image to the one below
# FROM mcr.microsoft.com/azure-functions/dotnet:4-appservice
FROM mcr.microsoft.com/azure-functions/dotnet:4
ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
    AzureFunctionsJobHost__Logging__Console__IsEnabled=true

COPY --from=installer-env ["/home/site/wwwroot", "/home/site/wwwroot"]

2. Compilar y publicar la imagen docker en nuestro Azure Container Registry

az acr login -n <AZURE-CONTAINER-REGISTRY-NAME>
docker build -t <AZURE-CONTAINER-REGISTRY-NAME>.azurecr.io/hello-functions .
docker push <AZURE-CONTAINER-REGISTRY-NAME>.azurecr.io/hello-functions

Azure Functions

3. Crear un nuevo fichero «deploy.yaml» en la carpeta raiz del proyecto, con el siguiente contenido:

apiVersion: v1
kind: Service

metadata:
  name: azure-function
  namespace: default
spec:
  selector:
    app: azure-function
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment

metadata:
  name: azure-function
  namespace: default
  labels:
    app: azure-function
spec:
  replicas: 1
  selector:
    matchLabels:
      app: azure-function
  template:
    metadata:
      labels:
        app: azure-function
      annotations:
        dapr.io/enabled: "true"
        dapr.io/port: "3001"
    spec:
      containers:
      - name: azure-function
        image: k8sappsregistry.azurecr.io/hello-functions 
        - containerPort: 80

4. Ejecutar las siguiente instrucción para desplegar las funciones en AKS.

kubectl apply -f .\deploy.yaml

Key Vault

5. Descargar el certificado de Key Vault.

az keyvault secret download --vault-name dapr-key-vault --name CertName --encoding base64 --file c:\users\jguerrerominero\dapr-keyvault.pfx

6. Incluir el certificado como secret de Kubernetes/AKS con una clave, por ejemplo: «key-vault-cert»

kubectl create secret generic key-vault-cert --from-file=C:\Users\jguerrerominero\dapr-keyvault.pfx

7. Ejecutar la siguientes instrucciones, indicando el TenanID y el ClientID. Ambos valores

kubectl create secret generic keyvaultclientid --from-literal=keyVaultClientId=<TENNAT-ID>
kubectl create secret generic keyvaulttenantid --from-literal=keyVaultTenantId=<CLIENT-ID>

8. Y, actualizar el componente Dapr «secretsstore» para que pase a ser el siguiente. Donde, en lugar de usar la propiedad «spnCertificateFile» como veíamos en el capítulo anterior, usamos «spnCertificate» e incluimos la sección «auth«, para indicar que el valor del certificado se encuentra en los Secrets de Kubernetes.

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: secretstore
  namespace: default
spec:
  type: secretstores.azure.keyvault
  version: v1
  metadata:
  - name: vaultName
    value: dapr-keyvault
  - name: spnTenantId
    secretKeyRef:
      name: keyvaulttenantid
      key: keyVaultTenantId
  - name: spnClientId    
    secretKeyRef:
      name: keyvaultclientid
      key: keyVaultClientId
  - name: spnCertificate
    secretKeyRef:
      name: key-vault-cert
      key: dapr-keyvault.pfx
  
auth:
  secretStore: kubernetes

Dapr

9. Ejecutar el siguiente comando para desplegar todos los componentes Dapr en el Cluster de Kubernetes/AKS.

kubectl apply -f .\hello-functions\dapr\components\.

Validación y Ejecución

10. Validamos también que en kubernetes el pod con los dos contenedores («hello-functions» y «dapr») están funcionando correctamente.

11. Para finalizar, desde línea de comandos, lanzamos el Dashboard de Dapr con «dapr dashboard -k» y vemos que todos está correcto.

11. La ejecución completa del flujo la lanzamos al igual que en el capítulo anterior, poniendo un mensaje en la cola a la que hace referencia el componente «queuebinding«.

12. Y todo concluye, puedes comprobarlo, recibiendo el email, 😉 ¡No incluyo más evidencias dado que ya las vinos en el capítulo anterior!

Happy #Dapr coding !!

Referencias

• https://github.com/dapr/dapr/issues/372