Implementar desenvolvimento e testes locais usando KT-Connect e ASM - Alibaba Cloud Service Mesh: Central de Documentação do Alibaba Cloud

O KT-Connect ("KT" é a abreviação de "Kubernetes Toolkit") é uma ferramenta utilitária que ajuda você a trabalhar com ambientes de desenvolvimento Kubernetes de forma mais eficiente. O proxy do KT-Connect utiliza o recurso de gerenciamento de tráfego no console do Alibaba Cloud Service Mesh (ASM) para depurar aplicações locais e acelerar o desenvolvimento e os testes locais. Este tópico descreve como implementar desenvolvimento e testes locais utilizando KT-Connect e ASM.

Contexto

O KtConnect é uma ferramenta open source projetada para ajudar desenvolvedores a simplificar processos de desenvolvimento em clusters Kubernetes. Ela permite implantar pods de proxy em clusters Kubernetes para redirecionar o tráfego destinado a serviços específicos para aplicações locais. Isso facilita o acesso mútuo entre ambientes locais e clusters Kubernetes. Os principais recursos do KT-Connect incluem:

Acesso a clusters Kubernetes a partir de aplicações locais.

O KT-Connect torna todos os recursos do cluster acessíveis para aplicações locais sem exigir modificações de modo.
Resolução local de nomes de domínio internos para serviços Kubernetes.

Resolve diretamente os nomes dos serviços para os endereços IP dos clusters onde residem, proporcionando uma verdadeira experiência cloud-native para o desenvolvimento local.
Redirecionamento de tráfego especificado para serviços do cluster para serviços em ambientes locais.

Roteia solicitações destinadas a um serviço específico no cluster para uma aplicação local, permitindo que todas as aplicações locais sejam acessadas diretamente pelos serviços do cluster.
Colaboração em ambiente de testes entre múltiplos usuários sem interferências.

Configure regras de roteamento para redirecionar apenas solicitações específicas para aplicações locais, sem afetar a disponibilidade do ambiente.
Suporte a ambientes de desenvolvimento Windows/MacOS/Linux.

Diversos sistemas operacionais com o mesmo método de uso permitem que os desenvolvedores acessem os serviços do cluster Kubernetes.

Pré-requisitos

Um gateway de entrada está implantado. Para mais informações, consulte Criar um gateway de entrada.
Uma aplicação está implantada no cluster adicionado à instância do ASM. Para mais informações, consulte Implantar uma aplicação em um cluster associado ao ASM.
O Docker e o Docker Compose estão instalados.

Preparações

Este exemplo demonstra o seguinte cenário:

Implantar uma aplicação helloworld v1 no cluster e configurar uma política de tráfego para a aplicação.
Usar o Docker para implantar uma aplicação helloworld v2 no ambiente local. Execute o comando ktctl para implantar um pod de proxy no cluster e habilitar a conexão do ambiente local com o cluster.
Atualize a política de roteamento para direcionar o tráfego para a aplicação v1 no cluster e para a aplicação v2 no ambiente local com base nos cabeçalhos das solicitações.

Instale e configure o ktctl.
Crie um namespace no cluster.
```
kubectl create ns mesh-demo
```
Ative a injeção automática de sidecar para o namespace.
```
kubectl label ns mesh-demo istio-injection=enabled
```

Procedimento

Etapa 1: Implantar aplicações e configurar políticas de roteamento

Implante as aplicações no 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

Implante uma política de roteamento.

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

Verifique se a política entrou em vigor.

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'

Saída esperada:

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

A saída mostra que o stage é online e a version é v1, conforme esperado.

Etapa 2: Implantar um ambiente de desenvolvimento local

Implante uma aplicação helloworld v2 usando 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"

Implante o proxy do KT-Connect no cluster. Dessa forma, um pod de proxy com o rótulo version=hzall é implantado no namespace mesh-demo.

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

Saída esperada:

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 ---------------------------------------------------------

Visualize o pod de proxy.

kubectl get pod -n mesh-demo

Saída esperada:

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

Neste caso, helloworld-kt-mesh-hzall é o pod de proxy implantado.

Etapa 3: Atualize a política de roteamento e verifique conexões

Atualize a política de roteamento. Encaminhe solicitações com o cabeçalho x-env=local para a aplicação helloworld v2 no ambiente local e encaminhe todas as outras solicitações para a aplicação helloworld v1 no 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

Acesse uma aplicação local:
```
curl ${INGRESS_HOST} -H 'host: helloworld.mesh.com' -H 'x-env: local'
```
Saída esperada:
```
Welcome to helloworld stage: local, version: v2, ip: 127.0.0.1
```
A saída indica que o stage é local e a version é v2. Isso confirma que a conectividade bidirecional entre serviços em ambientes locais e clusters foi configurada com sucesso, permitindo o acesso ao serviço local a partir do cluster.

Acesse uma aplicação no cluster.

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

Saída esperada:

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

(Opcional) Etapa 4: Limpar o ambiente

Exclua os recursos de teste do cluster criado.
```
kubectl delete ns mesh-demo
```
Interrompa a aplicação local.
```
docker stop local-container
```