Deploy the HTTPBin application - Alibaba Cloud Service Mesh - Centre de documentation Alibaba Cloud

HTTPBin est un outil de test HTTP open source destiné au débogage web. Une fois HTTPBin déployé dans votre maillage de services, vous pouvez inspecter les méthodes de requête, les en-têtes et les détails d'autorisation via de simples endpoints HTTP.

Cette rubrique explique comment déployer HTTPBin sur un cluster ACK, acheminer le trafic externe vers celui-ci via une passerelle d'entrée ASM et vérifier la configuration.

Prérequis

Avant de commencer, assurez-vous que :

Le cluster est ajouté à l'instance ASM.
Une passerelle d'entrée est déployée.
kubectl est configuré pour se connecter au cluster ACK du plan de données.

Étape 1 : Déployer HTTPBin sur le cluster ACK

L'application HTTPBin s'exécute dans le cluster Container Service for Kubernetes (ACK) du plan de données.

Enregistrez le code YAML suivant sous le nom httpbin-application.yaml.

Ce manifeste crée trois ressources : un ServiceAccount, un Service qui expose le port 8000 et un Deployment avec un seul réplica exécutant le conteneur HTTPBin.

httpbin-application.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
    service: httpbin
spec:
  ports:
  - name: http
    port: 8000
    targetPort: 80
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
      - image: registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/httpbin:0.1.0
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 80

Appliquez le manifeste :

kubectl apply -f httpbin-application.yaml

Vérifiez que le pod HTTPBin est en cours d'exécution :
```
kubectl get pods -l app=httpbin
```

Étape 2 : Configurer le routage du trafic

Pour acheminer le trafic externe vers HTTPBin, créez deux ressources Istio : une Gateway qui accepte les connexions entrantes à la périphérie du maillage et un VirtualService qui transfère les requêtes correspondantes vers le service HTTPBin.

Créer une passerelle Istio

Une Gateway définit les ports, les protocoles et les hôtes sur lesquels la passerelle d'entrée écoute. La Gateway ci-dessous accepte le trafic HTTP sur le port 80 pour tous les hôtes.

Pour plus d'informations, consultez la rubrique Gérer les passerelles Istio.

apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: httpbin
  namespace: default
spec:
  selector:
    istio: ingressgateway
  servers:
    - hosts:
        - '*'
      port:
        name: test
        number: 80
        protocol: HTTP

Créer un service virtuel

Un VirtualService est lié à la Gateway et définit les règles de routage. Le VirtualService ci-dessous achemine toutes les requêtes HTTP vers le service HTTPBin à l'adresse httpbin.default.svc.cluster.local:8000.

Pour plus d'informations, consultez la rubrique Gérer les services virtuels.

apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: httpbin-vs
  namespace: default
spec:
  gateways:
    - httpbin
  hosts:
    - '*'
  http:
    - name: test
      route:
        - destination:
            host: httpbin.default.svc.cluster.local
            port:
              number: 8000

Étape 3 : Vérifier le déploiement

Envoyez des requêtes via la passerelle d'entrée pour confirmer que HTTPBin répond correctement.

Remplacez ${GATEWAY_IP} dans les commandes suivantes par l'adresse IP réelle de la passerelle ASM. Pour savoir comment obtenir l'adresse IP de la passerelle, consultez la rubrique Obtenir l'adresse IP de la passerelle d'entrée.

Tester les codes d'état HTTP

L'endpoint /status/<code> renvoie le code d'état HTTP spécifié. Utilisez-le pour valider le bon transfert des requêtes par la passerelle.

# Expect: 200 OK
curl http://${GATEWAY_IP}/status/200 -v

# Expect: 418 Unknown
curl http://${GATEWAY_IP}/status/418 -v

# Expect: 403 Forbidden
curl http://${GATEWAY_IP}/status/403 -v

Tester le transfert des en-têtes

L'endpoint /headers renvoie tous les en-têtes inclus dans la requête. Il permet de vérifier que les en-têtes traversent intactes la passerelle et les proxies sidecar.

curl http://${GATEWAY_IP}/headers -H "test-header: test-value" -v

Le corps de la réponse contient tous les en-têtes de la requête, y compris test-header: test-value.

(Facultatif) Vérifier avec le service sleep

Au lieu d'utiliser curl depuis votre machine locale, déployez un pod sleep au sein du maillage et envoyez des requêtes depuis l'intérieur du cluster. Cette méthode confirme la connectivité de service à service via les sidecars Envoy.

Enregistrez le code YAML suivant sous le nom sleep.yaml.

##################################################################################################
# Sample sleep service
##################################################################################################
apiVersion: v1
kind: ServiceAccount
metadata:
  name: sleep
---
apiVersion: v1
kind: Service
metadata:
  name: sleep
  labels:
    app: sleep
    service: sleep
spec:
  ports:
  - port: 80
    name: http
  selector:
    app: sleep
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sleep
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sleep
  template:
    metadata:
      labels:
        app: sleep
    spec:
      terminationGracePeriodSeconds: 0
      serviceAccountName: sleep
      containers:
      - name: sleep
        image: registry.cn-hangzhou.aliyuncs.com/acs/curl:8.1.2
        command: ["/bin/sleep", "infinity"]
        imagePullPolicy: IfNotPresent
        volumeMounts:
        - mountPath: /etc/sleep/tls
          name: secret-volume
      volumes:
      - name: secret-volume
        secret:
          secretName: sleep-secret
          optional: true

Déployez le service sleep :
```
kubectl apply -f sleep.yaml -n default
```
Ouvrez un shell dans le pod sleep :
```
kubectl exec -it deploy/sleep -- sh
```

Envoyez une requête à HTTPBin depuis l'intérieur du maillage :

curl -I http://httpbin:8000/headers

Résultat attendu :

HTTP/1.1 200 OK
server: envoy
date: Tue, 26 Dec 2023 07:23:49 GMT
content-type: application/json
content-length: 353
access-control-allow-origin: *
access-control-allow-credentials: true
x-envoy-upstream-service-time: 1

Une réponse 200 OK avec server: envoy confirme que le trafic transite par le sidecar Envoy et atteint HTTPBin avec succès.

Nettoyage

Pour supprimer toutes les ressources créées dans cette rubrique :

kubectl delete -f httpbin-application.yaml
kubectl delete gateway httpbin -n default
kubectl delete virtualservice httpbin-vs -n default

# If you deployed the sleep service
kubectl delete -f sleep.yaml -n default