Implement local development and testing by using KT-Connect and ASM - Alibaba Cloud Service Mesh

KT-Connect (« KT » est l'abréviation de « Kubernetes Toolkit ») est un utilitaire conçu pour optimiser votre travail dans l'environnement de développement Kubernetes. Le proxy KT-Connect exploite la fonctionnalité de gestion du trafic disponible dans la console Alibaba Cloud Service Mesh (ASM) afin de déboguer vos applications locales et d'accélérer les phases de développement et de test. Cette rubrique explique comment mettre en œuvre le développement et les tests locaux en combinant KT-Connect et ASM.

Contexte

KtConnect est un outil open source qui aide les développeurs à simplifier leurs processus au sein des clusters Kubernetes. Il permet de déployer des pods proxy dans les clusters Kubernetes pour rediriger le trafic destiné à des services spécifiques vers des applications exécutées localement. Cette approche établit une connectivité bidirectionnelle entre les environnements locaux et les clusters Kubernetes. Les fonctionnalités principales de KT-Connect incluent :

Accès aux clusters Kubernetes depuis les applications locales.

KT-Connect rend toutes les ressources du cluster accessibles aux applications locales sans nécessiter de modification du mode de fonctionnement.
Résolution locale des noms de domaine internes des services Kubernetes.

Les noms de service sont résolus directement vers les adresses IP des clusters hébergeant ces services, offrant ainsi une expérience cloud-native authentique pour le développement local.
Redirection du trafic destiné aux services du cluster vers les services de l'environnement local.

Les requêtes adressées à un service spécifique du cluster sont routées vers une application locale, permettant aux services du cluster d'accéder directement à toutes les applications locales.
Collaboration dans l'environnement de test entre plusieurs utilisateurs, sans interférence.

Vous pouvez configurer des règles de routage pour rediriger uniquement certaines requêtes vers les applications locales, sans affecter la disponibilité globale de l'environnement.
Prise en charge des environnements de développement Windows, macOS et Linux.

Une méthode d'utilisation uniforme sur plusieurs systèmes d'exploitation permet aux développeurs d'accéder aux services des clusters Kubernetes.

Prérequis

Une passerelle d'entrée est déployée. Pour plus d'informations, consultez la rubrique Créer une passerelle d'entrée.
Une application est déployée dans le cluster associé à l'instance ASM. Pour plus d'informations, consultez la rubrique Déployer une application dans un cluster associé à ASM.
Docker et Docker Compose sont installés.

Préparatifs

Cet exemple illustre le scénario suivant :

Déploiement d'une application helloworld v1 dans le cluster et configuration d'une stratégie de trafic pour cette application.
Déploiement d'une application helloworld v2 dans l'environnement local à l'aide de Docker. Exécution de la commande ktctl pour déployer un pod proxy dans le cluster, permettant ainsi la connexion depuis l'environnement local vers le cluster.
Mise à jour de la stratégie de routage pour diriger le trafic vers l'application v1 dans le cluster et l'application v2 dans l'environnement local, en fonction des en-têtes de requête.

Installez et configurez ktctl.
Créez un namespace dans le cluster.
```
kubectl create ns mesh-demo
```
Activez l'injection automatique de sidecar pour le namespace.
```
kubectl label ns mesh-demo istio-injection=enabled
```

Procédure

Étape 1 : Déployer les applications et configurer les stratégies de routage

Déployez les applications dans le namespace mesh-demo.

kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloworld
  labels:
    app: helloworld
    version: v1
    stage: online
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloworld 
      version: v1
      stage: online
  template:
    metadata:
      labels:
        app: helloworld 
        version: v1
        stage: online
    spec:
      containers:
      - name: helloworld 
        env:
        - name: PODIP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
        - name: STAGE
          valueFrom:
            fieldRef:
              fieldPath: metadata.labels['stage']
        - name: VERSION 
          valueFrom:
            fieldRef:
              fieldPath: metadata.labels['version']
        command: ["/http-echo"]
        args:
          - "-text"
          - "Welcome to helloworld stage: $(STAGE), version: $(VERSION), ip: $(PODIP)"
        image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/asm-http-echo:1.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 5678
---
apiVersion: v1
kind: Service
metadata:
  name: helloworld
  labels:
    app: helloworld
    service: helloworld
spec:
  ports:
  - port: 8000
    name: http
    targetPort: 5678
  selector:
    app: helloworld
EOF

Déployez une stratégie de routage.

kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: helloworld-gateway
spec:
  selector:
    istio: ingressgateway
  servers:
  - hosts:
    - 'helloworld.mesh.com'
    port:
      name: http
      number: 80
      protocol: HTTP
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: helloworld
spec:
  host: helloworld
  subsets:
  - name: v1
    labels:
      version: v1
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: helloworld
spec:
  gateways:
  - helloworld-gateway
  hosts:
  - helloworld.mesh.com
  http:
  - route:
    - destination:
        host: helloworld
        subset: v1
EOF

Vérifiez si la stratégie est effective.

export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
curl ${INGRESS_HOST} -H 'host: helloworld.mesh.com'

Sortie attendue :

Welcome to helloworld stage: online, version: v1, ip: 172.23.16.246

La sortie indique que l'étape stage est online et que la version est v1, ce qui correspond au résultat attendu.

Étape 2 : Déployer un environnement de développement local

Déployez l'application helloworld v2 à l'aide de Docker.

docker run -itd --rm \
    --name local-container \
    -p 5678:5678 \
    registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/asm-http-echo:1.0 \
    -text "Welcome to helloworld stage: local, version: v2, ip: 127.0.0.1"

Déployez le proxy KT-Connect dans le cluster. Un pod proxy avec le libellé version=hzall est ainsi déployé dans le namespace mesh-demo.

ktctl -n mesh-demo mesh helloworld --expose 5678 --mode manual

Sortie attendue :

4:22PM INF Using cluster context cluster-4KvcBF (kubernetes)
4:22PM INF KtConnect 0.3.7 start at 59150 (darwin amd64)
4:22PM INF Fetching cluster time ...
4:22PM INF Using manual mode
4:22PM INF Successful create config map helloworld-kt-mesh-hzall
4:22PM INF Deploying shadow pod helloworld-kt-mesh-hzall in namespace mesh-demo
4:22PM INF Waiting for pod helloworld-kt-mesh-hzall ...
4:22PM INF Waiting for pod helloworld-kt-mesh-hzall ...
4:22PM INF Pod helloworld-kt-mesh-hzall is ready
4:22PM INF Forwarding pod helloworld-kt-mesh-hzall to local via port 5678
4:22PM INF Port forward local:17982 -> pod helloworld-kt-mesh-hzall:22 established
4:22PM INF Reverse tunnel 0.0.0.0:5678 -> 127.0.0.1:5678 established
4:22PM INF ---------------------------------------------------------
4:22PM INF  Now you can update Istio rule by label 'version=hzall' 
4:22PM INF ---------------------------------------------------------

Consultez le pod proxy.

kubectl get pod -n mesh-demo

Sortie attendue :

NAME                         READY   STATUS    RESTARTS   AGE
helloworld-5cbdxxxxx-xxxxx   2/2     Running   0          116m
helloworld-kt-mesh-hzall     2/2     Running   0          106m

Ici, helloworld-kt-mesh-hzall correspond au pod proxy déployé.

Étape 3 : Mettre à jour la stratégie de routage et vérifier les connexions

Mettez à jour la stratégie de routage. Transférez les requêtes contenant l'en-tête x-env=local vers l'application helloworld v2 dans l'environnement local, et dirigez toutes les autres requêtes vers l'application helloworld v1 dans le cluster.

kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: helloworld
spec:
  host: helloworld
  subsets:
  - name: v1
    labels:
      version: v1
  - name: local
    labels:
      version: hzall
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: helloworld
spec:
  gateways:
  - helloworld-gateway
  hosts:
  - helloworld.mesh.com
  http:
  - match:
    - headers: 
        x-env:
          exact: local
    route:
    - destination:
        host: helloworld
        subset: local
  - route:
    - destination:
        host: helloworld
        subset: v1
EOF

Accédez à une application locale :
```
curl ${INGRESS_HOST} -H 'host: helloworld.mesh.com' -H 'x-env: local'
```
Sortie attendue :
```
Welcome to helloworld stage: local, version: v2, ip: 127.0.0.1
```
La sortie indique que l'étape stage est local et que la version est v2. Cela confirme que la connectivité bidirectionnelle entre les services des environnements locaux et ceux du cluster est correctement configurée, permettant l'accès au service local depuis le cluster.

Accédez à une application dans le cluster.

curl ${INGRESS_HOST} -H 'host: helloworld.mesh.com'

Sortie attendue :

Welcome to helloworld stage: online, version: v1, ip: 172.23.16.246

(Facultatif) Étape 4 : Nettoyer l'environnement

Supprimez les ressources de test créées pour le cluster.
```
kubectl delete ns mesh-demo
```
Arrêtez l'application locale.
```
docker stop local-container
```