Terug

Microcks implementeren op OVHcloud Managed Kubernetes Service (MKS)

Aurélie Vache7 min leestijd
,
Microcks implementeren op OVHcloud Managed Kubernetes Service (MKS)

Je service is nu klaar om te testen, maar de API waarvan deze afhankelijk is, wordt pas over drie weken geleverd. Komt dit je bekend voor? Wanneer je een applicatie bouwt of test, zijn sommige API's waarvan deze afhankelijk is vaak nog niet beschikbaar, en dit kan frustrerend zijn.

API-mocking dicht dat gat: hiermee kun je jouw integraties testen zonder te wachten op de daadwerkelijke backend. Microcks voorziet in deze behoefte, en doet dit rechtstreeks vanuit je Kubernetes-cluster.

In dit blogbericht implementeer je Microcks op een OVHcloud Managed Kubernetes Service (MKS)-cluster en maak je het zichtbaar met de Kubernetes Gateway API, Envoy Gateway en een OVHcloud Public Cloud Load Balancer.

Als CNCF-project past Microcks helemaal vanzelf in een cloud-native omgeving. En aangezien OVHcloud een CNCF Platinum Member is, is het draaien van Microcks op MKS een vanzelfsprekende manier om API-mocking en testen op je Kubernetes-platform te doen.

Wat is Microcks?

Microcks-logo, de opensourcetool voor API-mocking en testen

Microcks is een opensourcetool voor API-mocking en testen.

Het maakt API-mocks op basis van API-specificaties, zodat je applicaties en integraties kunt testen zonder dat de daadwerkelijke backend beschikbaar hoeft te zijn.

Dit is vooral nuttig in gedistribueerde omgevingen, waar teams en services onafhankelijk van elkaar veranderen. En aangezien Microcks op Kubernetes draait, past het vanzelfsprekend in een cloud-native omgeving.

Vereisten

Voordat je begint, heb je het volgende nodig:

  • Een OVHcloud-account
  • Een OVHcloud Public Cloud-project
  • API-inloggegevens met de vereiste rechten om een MKS-cluster te beheren
  • De OVHcloud CLI
  • kubectl
  • Helm
  • Een domeinnaam (verwijzend naar de Load Balancer, als je een eigen domeinnaam wilt)

Starten maar.

Stap 1: Creëer het MKS-cluster

Je maakt eerst een OVHcloud Managed Kubernetes Service-cluster en een node pool.

Voor dit voorbeeld gebruik je een node pool met drie nodes van het type b3-8.

Let op: voor productiegebruik moet je overwegen om een Standard-pakket te gebruiken in plaats van het Free-pakket.

Creëer het cluster

Definieer je clusterparameters:

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

Creëer het Kubernetes-cluster:

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

Wacht 2–3 minuten totdat het cluster is ingericht.

Controleer de status van het Kubernetes-cluster:

bash
ovhcloud cloud mks get $CLUSTER_ID

Creëer de node pool en maak verbinding met het cluster

Microcks bestaat uit verschillende Kubernetes-workloads, waaronder de Microcks-applicatie, Keycloak en zijn PostgreSQL-instance, MongoDB en de Postman-runtime.

Voor een kleine installatie is een node pool met drie General Purpose nodes een redelijk startpunt.

Zodra het cluster is aangemaakt, kun je de node pool creëren. Definieer de configuratie van de node pool:

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

Creëer de node pool:

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}')

Wacht 3–4 minuten totdat de node pool is ingericht.

Controleer de status van de node pool:

bash
ovhcloud cloud mks nodepool get $CLUSTER_ID $NP_ID

Zodra het cluster en de node pool klaar zijn, genereer je de Kubernetes-configuratie:

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

Configureer de kubectl CLI met de gegenereerde kubeconfig:

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

Controleer of de nodes gereed zijn:

bash
kubectl get np
kubectl get nodes

Je Kubernetes-cluster is nu gereed. Je kunt nu Microcks zichtbaar gaan maken.

Stap 2: Maak het cluster zichtbaar met Gateway API

Gateway API is de Kubernetes-standaard voor het routeren van verkeer naar een cluster, ontworpen als opvolger van Ingress. Het beschrijft wat je wilt blootstellen; een controller zet die beschrijving vervolgens om in een draaiende proxy en, op MKS, in een OVHcloud Public Cloud Load Balancer.

Je gebruikt drie componenten: Envoy Gateway, een implementatie van Gateway API gebouwd op de Envoy-proxy; cert-manager, die TLS-certificaten automatiseert; en een Gateway-resource die deze met elkaar verbindt.

Installeer Envoy Gateway

Installeer de Envoy Gateway Helm-chart:

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

Maak vervolgens een GatewayClass aan die Kubernetes vertelt dat Envoy Gateway verantwoordelijk is voor je Gateway-resources:

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

Beheer TLS-certificaten met cert-manager

Om je TLS-certificaten automatisch te beheren, gebruik je cert-manager samen met Let's Encrypt.

Installeer 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

Maak vervolgens een ClusterIssuer aan voor 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

Deze issuer stelt cert-manager in staat om certificaten aan te vragen bij Let's Encrypt met behulp van de Gateway API HTTP-01 solver.

Maak de Gateway aan

Je kunt nu de Gateway maken die Microcks zichtbaar zal maken.

Maak de namespace aan:

bash
kubectl create namespace microcks

Maak vervolgens de Gateway aan met zijn vijf listeners: HTTP en HTTPS voor Microcks, TLS-passthrough voor gRPC, en HTTP en HTTPS voor 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

Controleer de status van de Gateway:

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

In dit stadium zou de Gateway Accepted=True en Programmed=True moeten zijn. Als dat nog niet zo is, wacht dan een paar minuten tot de Gateway is geprogrammeerd en de OVHcloud Public Cloud Load Balancer is ingericht.

Configureer DNS

Haal het externe adres op dat aan de Gateway is toegewezen:

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

Als je een aangepast domein gebruikt, maak dan de volgende DNS-records aan:

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

Je kunt deze records configureren via de DNS-beheerinterface van OVHcloud:

Microcks implementeren

Verifieer de records nadat DNS geconfigureerd is:

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

Stap 3: Microcks implementeren en verifiëren

De infrastructuur is nu klaar. Nu gaan we Microcks implementeren.

Microcks implementeren met Helm

Je gebruikt de officiële Microcks Helm-chart en configureert deze om Gateway API HTTPRoute-resources te maken in plaats van Kubernetes Ingress-resources.

Voeg de Microcks Helm-repository toe:

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

Maak een microcks_values.yaml-bestand aan:

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

Installeer Microcks:

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

Controleer de implementatie

Controleer de pods:

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

Wacht tot alle pods de status Running hebben en de containers klaar zijn.

Je kunt ook de Gateway API-routes controleren:

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

De routes moeten verwijzen naar de hostnamen voor Microcks en Keycloak die al zijn geconfigureerd.

Nu zou Microcks bereikbaar moeten zijn via:

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

Je hebt nu Microcks draaiend op een OVHcloud Managed Kubernetes Service-cluster, zichtbaar gemaakt via Gateway API en beveiligd met TLS-certificaten beheerd door cert-manager.

Conclusie en volgende stappen

In dit blogbericht heb je Microcks geïmplementeerd op een OVHcloud Managed Kubernetes Service-cluster en dit zichtbaar gemaakt met een Kubernetes Gateway API-implementatie van Envoy Gateway en een OVHcloud Public Cloud Load Balancer. TLS-certificaten worden beheerd met cert-manager en Let's Encrypt.

Je kunt nu direct vanaf een MKS-cluster API's mocken en testen.

Voor een productieomgeving zou een andere optie zijn om OVHcloud Managed Databases voor PostgreSQL en MongoDB te gebruiken in plaats van deze databasecomponenten direct in het Kubernetes-cluster uit te voeren. Deze werkwijze scheidt het applicatieplatform van de database-infrastructuur en je benut zo beheerde databaseservices.

Klaar om het te proberen? Maak je eerste Managed Kubernetes-cluster aan en implementeer Microcks in minder dan 30 minuten. Bekijk de Cloud Roadmap & Changelog om de nieuwste features van OVHcloud Public Cloud-producten te volgen.

Delen op: