Indietro

Deploy di Microcks su Managed Kubernetes Service (MKS) di OVHcloud

Aurélie Vache8 min. di lettura
,
Deploy di Microcks su Managed Kubernetes Service (MKS) di OVHcloud

Il tuo servizio è pronto per la fase di test, ma l'API su cui si basa non è disponibile per altre tre settimane. Ti suona familiare? Quando costruisci o testi un'applicazione, un aspetto frustrante è che spesso alcune delle API su cui si basa non sono disponibili.

L’API mocking risolve questo problema: consente di testare le integrazioni senza dover attendere il backend reale. Microcks risponde a questa esigenza direttamente dal tuo cluster Kubernetes.

In questo post ti spieghiamo come implementare Microcks su un cluster Managed Kubernetes Service (MKS) di OVHcloud e come esporlo utilizzando la Kubernetes Gateway API, Envoy Gateway e un Load Balancer Public Cloud di OVHcloud.

Essendo un progetto CNCF, Microcks è perfettamente adatto a un ambiente cloud-native. Inoltre, dato che OVHcloud è Platinum Member CNCF, eseguire Microcks su MKS ti permette di portare senza sforzo il mocking e il testing delle API sulla tua piattaforma Kubernetes.

Cos'è Microcks?

Logo di Microcks, lo strumento open source per il mocking e il testing delle API

Microcks è uno strumento open source per il mocking e il testing delle API.

Crea API di simulazione da API specifiche, permettendoti di testare le applicazioni e le integrazioni senza che il backend reale debba essere disponibile.

Si tratta di una piattaforma particolarmente utile negli ambienti distribuiti, in cui i team e i servizi evolvono in modo indipendente. Poiché Microcks è basato su Kubernetes, si integra naturalmente in un ambiente cloud-native.

Prerequisiti

Prima di iniziare, avrai bisogno di:

  • Un account OVHcloud
  • Un progetto Public Cloud OVHcloud
  • Le credenziali API con i permessi necessari per gestire un cluster MKS
  • La CLI OVHcloud
  • kubectl
  • Helm
  • Un dominio (che punta al Load Balancer, se desideri un dominio personalizzato)

Cominciamo!

Step 1: crea il cluster MKS

Prima di tutto, crea un cluster Managed Kubernetes Service OVHcloud e un pool di nodi.

Per questo esempio, utilizzeremo un pool di tre nodi basato sul flavor b3-8.

NB: per l'uso in produzione, valuta l'utilizzo di un piano standard invece del piano free.

Crea il cluster

Definisci i parametri del cluster:

bash
export CLUSTER_NAME="microcks"
export REGION="GRA9"
export PLAN="free"

Crea il cluster Kubernetes:

bash
CLUSTER_ID=$(ovhcloud cloud mks create --name $CLUSTER_NAME --region $REGION --plan $PLAN | grep -oE '[0-9a-f-]{36}')

Attendi il completamento del provisioning del cluster per 2/3 minuti.

Controlla lo stato del cluster Kubernetes:

bash
ovhcloud cloud mks get $CLUSTER_ID

Crea il pool di nodi e connettiti al cluster

Microcks è composto da workload Kubernetes, tra cui l'applicazione Microcks, Keycloak e la sua istanza PostgreSQL, MongoDB e il runtime Postman.

Per una piccola installazione, un pool di nodi con tre nodi general-purpose è un buon punto di partenza.

Una volta creato il cluster, puoi creare il pool di nodi. Definisci la configurazione del pool di nodi:

bash
export NODEPOOL_NAME="microcks-np"
export NODE_FLAVOR="b3-8"

Crea il pool di nodi:

bash
NP_ID=$(ovhcloud cloud mks nodepool create $CLUSTER_ID --flavor-name $NODE_FLAVOR --name $NODEPOOL_NAME --desired-nodes 3 --min-nodes 2 --max-nodes 3 | grep -oE '[0-9a-f-]{36}')

Attendi il completamento del provisioning del pool di nodi per 3/4 minuti.

Controlla lo stato del pool di nodi:

bash
ovhcloud cloud mks nodepool get $CLUSTER_ID $NP_ID

Una volta che il cluster e il pool di nodi sono pronti, genera la configurazione Kubernetes:

bash
ovhcloud cloud mks kubeconfig generate $CLUSTER_ID > microcks.yaml

Configura la CLI kubectl con il kubeconfig generato:

bash
export KUBECONFIG=$(pwd)/microcks.yaml

Verifica che i nodi siano pronti:

bash
kubectl get np
kubectl get nodes

Il tuo cluster Kubernetes è pronto: puoi esporre Microcks.

Step 2. Esponi il cluster con Gateway API

Gateway API è lo standard di Kubernetes per il routing del traffico in un cluster, progettato come successore di Ingress. La sua funzione è di descrivere ciò che vuoi esporre. In seguito, un controller trasforma questa descrizione in un proxy in esecuzione e, su MKS, in un Load Balancer Public Cloud di OVHcloud.

Utilizzerai tre componenti: Envoy Gateway, un'implementazione di Gateway API basata sul proxy Envoy; cert-manager, che automatizza i certificati TLS e una risorsa Gateway che li collega tra loro.

Installa Envoy Gateway

Installa il Chart Helm di Envoy Gateway:

bash
helm install envoy-gateway oci://docker.io/envoyproxy/gateway-helm -n envoy-gateway-system --create-namespace

Quindi, crea una GatewayClass che comunica a Kubernetes che Envoy Gateway è responsabile delle risorse Gateway:

bash
cat <<EOF | kubectl apply -f -
apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: envoy
spec:
  controllerName: gateway.envoyproxy.io/gatewayclass-controller
EOF

Gestisci i certificati TLS con cert-manager

Per gestire automaticamente i tuoi certificati TLS, utilizzerai cert-manager insieme a Let's Encrypt.

Installa cert-manager:

bash
helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --set crds.enabled=true --set config.gatewayAPI.enabled=true

Crea un ClusterIssuer per Let's Encrypt:

bash
cat <<EOF | kubectl apply -f -
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod-microcks
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: <your-email@example.com>   # Update with your email address
    privateKeySecretRef:
      name: letsencrypt-prod-microcks
    solvers:
      - http01:
          gatewayHTTPRoute:
            parentRefs:
              - name: microcks-gateway
                namespace: microcks
                group: gateway.networking.k8s.io
                kind: Gateway
EOF

Questo issuer consente a cert-manager di richiedere certificati a Let's Encrypt utilizzando il solver Gateway API HTTP-01.

Crea il Gateway

Ora puoi creare il Gateway che esporrà Microcks.

Crea il namespace:

bash
kubectl create namespace microcks

In seguito, crea il Gateway con i suoi cinque listener: HTTP e HTTPS per Microcks, TLS passthrough per gRPC, e HTTP e HTTPS per Keycloak.

bash
cat <<EOF | kubectl apply -f -
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: microcks-gateway
  namespace: microcks
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod-microcks
spec:
  gatewayClassName: envoy
  listeners:
    - name: microcks-http
      hostname: microcks.<YOUR_DOMAIN>.com
      protocol: HTTP
      port: 80
      allowedRoutes:
        namespaces:
          from: Same
    - name: microcks-https
      hostname: microcks.<YOUR_DOMAIN>.com
      protocol: HTTPS
      port: 443
      tls:
        mode: Terminate
        certificateRefs:
          - name: microcks-tls
      allowedRoutes:
        namespaces:
          from: Same
    - name: microcks-grpc
      hostname: microcks-grpc.<YOUR_DOMAIN>.com
      protocol: TLS
      port: 443
      tls:
        mode: Passthrough
      allowedRoutes:
        namespaces:
          from: Same
    - name: keycloak-http
      hostname: keycloak.<YOUR_DOMAIN>.com
      protocol: HTTP
      port: 80
      allowedRoutes:
        namespaces:
          from: Same
    - name: keycloak-https
      hostname: keycloak.<YOUR_DOMAIN>.com
      protocol: HTTPS
      port: 443
      tls:
        mode: Terminate
        certificateRefs:
          - name: keycloak-tls
      allowedRoutes:
        namespaces:
          from: Same
EOF

Controlla lo stato del Gateway:

bash
kubectl get gateway -n microcks
--- OUTPUT ---
NAME               CLASS   ADDRESS        PROGRAMMED   AGE
microcks-gateway   envoy   xx.xx.xx.xx    True         3m49s

In questa fase, il Gateway dovrebbe essere Accepted=True e Programmed=True. Se non lo è ancora, attendi qualche minuto il completamento della programmazione del Gateway e del provisioning del Load Balancer Public Cloud OVHcloud.

Configura DNS

Ottieni l'indirizzo esterno assegnato al Gateway:

bash
export GATEWAY_IP=$(kubectl get gateway microcks-gateway \
  -n microcks \
  -o jsonpath='{.status.addresses[0].value}')
 
echo $GATEWAY_IP
--- OUTPUT ---
xx.xx.xx.xx

Se stai utilizzando un dominio personalizzato, crea i seguenti record DNS:

bash
microcks.<YOUR_DOMAIN>.com       A    <GATEWAY_IP>
microcks-grpc.<YOUR_DOMAIN>.com  A    <GATEWAY_IP>
keycloak.<YOUR_DOMAIN>.com       A    <GATEWAY_IP>

Puoi configurare questi record tramite l'interfaccia di gestione DNS di OVHcloud:

deploy Microcks

Una volta configurato il DNS, verifica i record:

bash
dig keycloak.<YOUR_DOMAIN>.com +noall +answer
dig microcks.<YOUR_DOMAIN>.com +noall +answer
dig microcks-grpc.<YOUR_DOMAIN>.com +noall +answer

Step 3: deploy e verifica di Microcks

L'infrastruttura è pronta. Ora possiamo implementare Microcks.

Deploy di Microcks con Helm

Utilizza il chart Helm ufficiale di Microcks e configuralo per creare risorse Gateway API HTTPRoute invece di risorse Ingress di Kubernetes.

Aggiungi il repository Helm di Microcks:

bash
helm repo add microcks https://microcks.io/helm/
helm repo update

Crea un file microcks_values.yaml:

bash
cat > microcks_values.yaml <<EOF
appName: microcks
 
ingresses: false
gatewayRoutes: true
 
gatewayRefName: microcks-gateway
gatewayRefNamespace: microcks
gatewayRefSectionName: microcks-https
grpcGatewayRefSectionName: microcks-grpc
 
microcks:
  url: microcks.<YOUR_DOMAIN>.com
  ingressSecretRef: microcks-tls
  generateCert: false
  grpcEnableTLS: true
 
keycloak:
  url: keycloak.<YOUR_DOMAIN>.com
  privateUrl: http://microcks-keycloak.microcks.svc.cluster.local:8080
  ingressSecretRef: keycloak-tls
  generateCert: false
  gatewayRefName: microcks-gateway
  gatewayRefNamespace: microcks
  gatewayRefSectionName: keycloak-https
EOF

Installa Microcks:

bash
helm install microcks microcks/microcks -n microcks -f microcks_values.yaml

Verifica il deploy

Controlla i pod:

bash
kubectl get pods -n microcks
--- OUTPUT ---
NAME                                           READY   STATUS    RESTARTS       AGE
microcks-7f9f994fbc-jd7pb                      1/1     Running   0              19m
microcks-keycloak-5cf68c6b65-xjr6n             1/1     Running   3 (3m1s ago)   19m
microcks-keycloak-postgresql-6665b755f-zjdrl   1/1     Running   0              19m
microcks-mongodb-7ddff9f544-8rdcx              1/1     Running   0              19m
microcks-postman-runtime-5699859b86-58mr7      1/1     Running   0              19m

Aspetta che tutti i pod siano nello stato Running e i container siano pronti.

Puoi anche controllare le rotte della Gateway API:

bash
kubectl get httproute -n microcks
--- OUTPUT ---
NAME                HOSTNAMES                          AGE
microcks            ["microcks.<YOUR_DOMAIN>.com"]     3m34s
microcks-keycloak   ["keycloak.<YOUR_DOMAIN>.com"]     3m34s

Le rotte dovrebbero fare riferimento agli hostname Microcks e Keycloak configurati in precedenza.

A questo punto, Microcks dovrebbe essere accessibile tramite:

bash
https://microcks.<YOUR_DOMAIN>.com
https://microcks-grpc.<YOUR_DOMAIN>.com
https://keycloak.<YOUR_DOMAIN>.com

Ora Microcks è in esecuzione su un cluster OVHcloud Managed Kubernetes Service, esposto tramite Gateway API e protetto con certificati TLS gestiti da cert-manager.

Conclusione e prossimi step

In questo post hai scoperto come implementare Microcks su un cluster Managed Kubernetes Service di OVHcloud e l'hai esposto utilizzando l'implementazione della Kubernetes Gateway API di Envoy Gateway e un Load Balancer del Public Cloud OVHcloud. I certificati TLS sono gestiti con cert-manager e Let's Encrypt.

Ora puoi eseguire il mocking e il testing delle API direttamente da un cluster MKS.

Per un ambiente di produzione, un'altra opzione è quella di utilizzare OVHcloud Managed Databases per PostgreSQL e MongoDB invece di eseguire questi componenti di database direttamente nel cluster Kubernetes. Questo approccio separa la piattaforma di applicazione dall'infrastruttura del database e consente di usufruire di servizi di database gestiti.

Sei pronto? Crea il tuo primo cluster Managed Kubernetes e implementa Microcks in meno di 30 minuti. Per seguire le ultime funzionalità in arrivo per i prodotti OVHcloud Public Cloud, dai un'occhiata a Cloud Roadmap & Changelog.

Condividi su::