Zurück

Microcks auf OVHcloud Managed Kubernetes Service (MKS) bereitstellen

Aurélie Vache7 Minuten Lesezeit
,
Microcks auf OVHcloud Managed Kubernetes Service (MKS) bereitstellen

Ihr Dienst ist nun bereit zum Testen, aber die API, von der er abhängt, wird erst in drei Wochen veröffentlicht. Klingt das vertraut? Wenn Sie eine Anwendung erstellen oder testen, sind einige der APIs, auf die sie sich stützt, oft noch nicht verfügbar, und das kann frustrierend sein.

API-Mocking schließt diese Lücke: Sie können damit Ihre Integrationen testen, ohne auf das tatsächliche Backend warten zu müssen. Microcks nimmt sich dieser Anforderung an – und das direkt aus Ihrem Kubernetes-Cluster heraus.

In diesem Blogbeitrag geht es darum, Microcks auf einem OVHcloud Managed Kubernetes Service (MKS) Cluster bereitzustellen und es dann mit Kubernetes Gateway API, Envoy Gateway und einem OVHcloud Public Cloud Load Balancer verfügbar zu machen.

Als CNCF-Projekt ist Microcks von Natur aus für Cloud-native Umgebungen geeignet. Da OVHcloud CNCF-Platin-Mitglied ist, ist die Ausführung von Microcks auf MKS eine natürliche Möglichkeit, API-Mocking und -Testing in Ihre Kubernetes-Plattform zu integrieren.

Was ist Microcks?

Microcks Logo, das Open-Source-API-Mocking- und Test-Tool

Microcks ist ein Open-Source-Tool für das API-Mocking und -Testing.

Es erstellt API-Mocks aus API-Spezifikationen, sodass Sie Anwendungen und Integrationen testen können, ohne dass das eigentliche Backend zur Verfügung stehen muss.

Das ist besonders in verteilten Umgebungen nützlich, in denen Teams und Dienste unabhängig voneinander wachsen. Da Microcks auf Kubernetes läuft, fügt es sich nahtlos in eine Cloud-native Umgebung ein.

Voraussetzungen

Bevor Sie loslegen, benötigen Sie:

  • Einen OVHcloud Account
  • Ein aktives OVHcloud Public-Cloud-Projekt
  • API-Anmeldeinformationen mit den Berechtigungen, die zum Verwalten eines MKS Clusters erforderlich sind
  • Die OVHcloud CLI
  • kubectl
  • Helm
  • Ein Domainname (der auf den Loadbalancer verweist, wenn Sie einen individuellen Domainnamen wünschen)

Dann kann es auch schon losgehen.

Schritt 1: MKS Cluster erstellen

Zunächst erstellen Sie einen OVHcloud Managed Kubernetes Service Cluster und einen Node-Pool.

Für dieses Beispiel entscheiden wir uns für einen Pool mit drei Nodes auf b3-8-Basis.

Beachten Sie, dass Sie für die Produktion die Verwendung eines Standard-Plans anstelle des kostenlosen Plans in Betracht ziehen sollten.

Cluster erstellen

Definieren Sie Ihre Cluster-Parameter:

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

Erstellen Sie den Kubernetes-Cluster:

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

Warten Sie 2–3 Minuten, bis der Cluster bereitgestellt ist.

Überprüfen Sie den Status des Kubernetes-Clusters:

bash
ovhcloud cloud mks get $CLUSTER_ID

Node-Pool erstellen und mit dem Cluster verbinden

Microcks besteht aus mehreren Kubernetes-Workloads, darunter die Microcks-Anwendung, Keycloak und seine PostgreSQL-Instanz, MongoDB und die Postman-Runtime.

Für eine kleine Installation ist ein Node-Pool mit drei Nodes für allgemeine Anforderungen (General Purpose) ein sinnvoller Ausgangspunkt.

Nachdem der Cluster erstellt wurde, können Sie den Node-Pool erstellen. Definieren Sie die Konfiguration des Node-Pools:

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

Erstellen Sie den 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}')

Warten Sie 3–4 Minuten, bis der Node-Pool bereitgestellt wurde.

Überprüfen Sie den Status des Node-Pools:

bash
ovhcloud cloud mks nodepool get $CLUSTER_ID $NP_ID

Sobald der Cluster und der Node-Pool bereit sind, generieren Sie die Kubernetes-Konfiguration:

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

Konfigurieren Sie die kubectl-CLI mit der generierten kubeconfig:

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

Überprüfen Sie, ob die Nodes bereit sind:

bash
kubectl get np
kubectl get nodes

Ihr Kubernetes-Cluster ist jetzt bereit. Sie können jetzt fortfahren und Microcks verfügbar machen.

Schritt 2: Cluster mit Gateway API verfügbar machen

Gateway API ist der Kubernetes-Standard für die Weiterleitung von Traffic in einen Cluster und wurde als Nachfolger von Ingress entwickelt. Sie beschreibt, was Sie verfügbar machen möchten. Ein Controller wandelt diese Beschreibung in einen laufenden Proxy und auf MKS in einen OVHcloud Public Cloud Load Balancer um.

Sie verwenden drei Komponenten: Envoy Gateway (eine Implementierung der Gateway API, die auf dem Envoy-Proxy basiert), cert-manager, der TLS-Zertifikate automatisiert, und eine Gateway-Ressource, die sie miteinander verbindet.

Envoy Gateway installieren

Installieren Sie das Envoy Gateway-Helm-Chart:

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

Erstellen Sie dann eine GatewayClass, die Kubernetes mitteilt, dass Envoy Gateway für Ihre Gateway-Ressourcen zuständig ist:

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

TLS-Zertifikate mit cert-manager verwalten

Um Ihre TLS-Zertifikate automatisch zu verwalten, verwenden Sie cert-manager in Verbindung mit Let’s Encrypt.

cert-manager installieren:

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

Erstellen Sie dann einen ClusterIssuer für 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

Dieser Issuer erlaubt es cert-manager, mit dem Gateway API HTTP-01-Solver Zertifikate von Let’s Encrypt anzufordern.

Gateway erstellen

Sie können jetzt das Gateway erstellen, das Microcks verfügbar macht.

Erstellen Sie den Namespace:

bash
kubectl create namespace microcks

Erstellen Sie dann das Gateway mit seinen fünf Listenern: HTTP und HTTPS für Microcks, TLS-Passthrough für gRPC und HTTP und HTTPS für 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

Überprüfen Sie den Status des Gateways:

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

In diesem Stadium sollte das Gateway Accepted=True und Programmed=True sein. Wenn das noch nicht der Fall ist, warten Sie ein paar Minuten, bis das Gateway programmiert und der OVHcloud Public Cloud Load Balancer bereitgestellt ist.

DNS konfigurieren

Rufen Sie die externe Adresse des Gateways ab:

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

Wenn Sie eine individuelle Domain verwenden, erstellen Sie die folgenden DNS-Einträge:

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

Sie können diese Einträge über die OVHcloud DNS-Verwaltungsoberfläche konfigurieren:

Microcks bereitstellen

Nachdem Ihr DNS konfiguriert ist, überprüfen Sie die Einträge:

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

Schritt 3: Microcks bereitstellen und überprüfen

Die Infrastruktur ist nun bereit. Jetzt deployen wir Microcks.

Microcks mit Helm bereitstellen

Sie verwenden das offizielle Microcks-Helm-Chart und konfigurieren es, um Gateway API HTTPRoute-Ressourcen anstelle von Kubernetes Ingress-Ressourcen zu erstellen.

Fügen Sie das Microcks-Helm-Repository hinzu:

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

Erstellen Sie eine microcks_values.yaml-Datei:

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

Installieren Sie Microcks:

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

Deployment überprüfen

Überprüfen Sie die 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

Warten Sie, bis alle Pods im Zustand „Running“ sind und die Container bereit sind.

Sie können auch die Gateway API-Routen überprüfen:

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

Die Routen sollten auf die zuvor konfigurierten Microcks- und Keycloak-Hostnamen verweisen.

Ab diesem Zeitpunkt sollte Microcks über folgende Links zugänglich sein:

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

Microcks läuft jetzt auf einem OVHcloud Managed Kubernetes Service Cluster, ist über die Gateway API zugänglich und ist mit TLS-Zertifikaten abgesichert, die von cert-manager verwaltet werden.

Fazit und Ausblick

In diesem Blogbeitrag haben wir Microcks auf einem OVHcloud Managed Kubernetes Service Cluster bereitgestellt und es mit der Kubernetes Gateway API-Implementierung von Envoy Gateway und einem OVHcloud Public Cloud Load Balancer verfügbar gemacht. TLS-Zertifikate werden mit cert-manager und Let's Encrypt verwaltet.

Sie können APIs jetzt direkt von einem MKS-Cluster aus mocken und testen.

Für eine Produktionsumgebung wäre eine weitere Option die Verwendung von OVHcloud Managed Databases for PostgreSQL und MongoDB anstelle des direkten Ausführens dieser Datenbankkomponenten im Kubernetes-Cluster. Dieser Ansatz trennt die Anwendungsplattform von der Datenbankinfrastruktur und ermöglicht Ihnen die Nutzung von verwalteten Datenbankdiensten.

Bereit, es auszuprobieren? Erstellen Sie Ihren ersten Managed Kubernetes-Cluster und stellen Sie Microcks in weniger als 30 Minuten bereit. Informationen zu den neuesten Funktionen der OVHcloud Public-Cloud-Produkte finden Sie hier: Cloud Roadmap & Changelog.

Teilen auf: