Preparativos para implementar recursos de roteamento L7 - Alibaba Cloud Service Mesh: Central de Documentação do Alibaba Cloud

O roteamento de Camada 7 no Service Mesh (ASM) direciona o tráfego com base em caminhos de URI e cabeçalhos de requisição. Antes de configurar as regras de roteamento, prepare o ambiente ASM e implante as aplicações de exemplo necessárias para o seu caso de uso.

Este tópico aborda duas etapas:

Atenda aos pré-requisitos: crie uma instância do ASM, adicione um cluster e ative a injeção automática de proxy sidecar.
Implante as aplicações de exemplo: implante os serviços necessários para o seu caso de uso de roteamento de Camada 7.

Pré-requisitos

Antes de começar, verifique se você tem:

Uma instância do ASM da Enterprise Edition. Consulte Criar uma instância do ASM.

Importante
Na seção Dataplane Mode da página Create Service Mesh, não selecione Enable Ambient Mesh mode. O roteamento de Camada 7 com proxies sidecar é incompatível com o modo ambient mesh.
Um cluster do Container Service for Kubernetes (ACK). Consulte Criar um cluster dedicado do ACK ou Criar um cluster gerenciado do ACK.
Cluster adicionado à instância do ASM.
**Injeção automática de proxy sidecar ativada para o namespace default**. Consulte a seção "Enable automatic sidecar proxy injection" em Gerenciar namespaces globais.

Implantar aplicações de exemplo

Implante um ou mais dos serviços abaixo no cluster ACK, conforme o caso de uso de roteamento de Camada 7 que você pretende configurar.

Serviço	Porta	Caso de uso
helloworld	5000	Roteamento baseado em versão (divisão de tráfego v1/v2)
sleep	80	Pod cliente para envio de requisições de teste a outros serviços
HTTPBin	8000	Correspondência de cabeçalho e caminho
NGINX	8000	Roteamento HTTP básico e balanceamento de carga

Todos os comandos de implantação abaixo pressupõem que o kubectl esteja configurado para se conectar ao cluster ACK por meio do arquivo kubeconfig.

Implantar o serviço helloworld

O serviço helloworld executa duas versões (v1 e v2), ideal para testar regras de roteamento baseadas em versão.

Salve o YAML a seguir em um arquivo chamado helloworld-application.yaml:

helloworld-application.yaml

apiVersion: v1
kind: Service
metadata:
  name: helloworld
  labels:
    app: helloworld
spec:
  ports:
  - port: 5000
    name: http
  selector:
    app: helloworld
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: helloworld
  labels:
    account: helloworld
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloworld-v1
  labels:
    apps: helloworld
    version: v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloworld
      version: v1
  template:
    metadata:
      labels:
        app: helloworld
        version: v1
    spec:
      serviceAccount: helloworld
      serviceAccountName: helloworld
      containers:
      - name: helloworld
        image: istio/examples-helloworld-v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 5000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloworld-v2
  labels:
    apps: helloworld
    version: v2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloworld
      version: v2
  template:
    metadata:
      labels:
        app: helloworld
        version: v2
    spec:
      serviceAccount: helloworld
      serviceAccountName: helloworld
      containers:
      - name: helloworld
        image: istio/examples-helloworld-v2
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 5000

Aplique o manifesto:

   kubectl apply -f helloworld-application.yaml

Verifique se os pods estão em execução com os proxies sidecar injetados (a coluna READY exibe 2/2). Saída esperada:

   kubectl get pods -l app=helloworld

   NAME                              READY   STATUS    RESTARTS   AGE
   helloworld-v1-xxxxxxxxx-xxxxx     2/2     Running   0          30s
   helloworld-v2-xxxxxxxxx-xxxxx     2/2     Running   0          30s

Implantar o serviço sleep

O serviço sleep fornece um pod com curl para envio de requisições de teste a outros serviços na malha.

Salve o YAML a seguir em um arquivo chamado sleep-application.yaml:

sleep-application.yaml

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: curlimages/curl
        command: ["/bin/sleep", "3650d"]
        imagePullPolicy: IfNotPresent
        volumeMounts:
        - mountPath: /etc/sleep/tls
          name: secret-volume
      volumes:
      - name: secret-volume
        secret:
          secretName: sleep-secret
          optional: true

Aplique o manifesto:

   kubectl apply -f sleep-application.yaml

Verifique se o pod sleep está em execução com o proxy sidecar. Saída esperada:

   kubectl get pods -l app=sleep

   NAME                     READY   STATUS    RESTARTS   AGE
   sleep-xxxxxxxxx-xxxxx    2/2     Running   0          30s

Implantar o serviço HTTPBin

O HTTPBin retorna dados estruturados de resposta HTTP, útil para testar correspondência de cabeçalhos e roteamento baseado em caminho.

Salve o YAML a seguir em um arquivo chamado httpbin-application.yaml:

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: docker.io/kennethreitz/httpbin
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 80

Aplique o manifesto:

   kubectl apply -f httpbin-application.yaml

Verifique se o pod HTTPBin está em execução. Saída esperada:

   kubectl get pods -l app=httpbin

   NAME                       READY   STATUS    RESTARTS   AGE
   httpbin-xxxxxxxxx-xxxxx    2/2     Running   0          30s

Implantar o serviço NGINX

O NGINX atua como backend HTTP básico para testar regras padrão de roteamento e balanceamento de carga.

Salve o YAML a seguir em um arquivo chamado nginx.yaml:

nginx.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: nginx
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app: nginx
    service: nginx
  name: nginx
spec:
  ports:
    - name: http
      port: 8000
      protocol: TCP
      targetPort: 80
  selector:
    app: nginx
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: nginx
    version: v1
  name: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
      version: v1
  template:
    metadata:
      labels:
        app: nginx
        version: v1
    spec:
      serviceAccountName: nginx
      containers:
        - image: 'nginx:1.7.9'
          name: nginx
          ports:
            - containerPort: 80
          terminationMessagePath: /dev/termination-log
          terminationMessagePolicy: File

Aplique o manifesto:
```
   kubectl apply -f nginx.yaml
```

Verifique se o pod NGINX está em execução. Saída esperada:

   kubectl get pods -l app=nginx

   NAME                     READY   STATUS    RESTARTS   AGE
   nginx-xxxxxxxxx-xxxxx    2/2     Running   0          30s

Confirme o registro de serviços

Após implantar as aplicações de exemplo, confirme se os serviços estão registrados no cluster:

kubectl get services

Certifique-se de que cada serviço implantado apareça na saída com a porta esperada.

Próximos passos

Após concluir esses preparativos, prossiga para o caso de uso de roteamento de Camada 7 correspondente ao seu cenário. Cada caso de uso especifica as aplicações de exemplo necessárias.