Esercitazione: Usare Telepresence per sviluppare e testare microservizi in locale

2025-01-23

Telepresence è un progetto SANDBOX DI CLOUD Native Computing Foundation creato dal team di Ambassador Labs. La telepresenza consente agli sviluppatori di eseguire servizi in locale nel computer di sviluppo mentre si è connessi a un cluster Kubernetes remoto. Questa configurazione semplifica lo sviluppo, il debug e il test di applicazioni che interagiscono con altri servizi nel cluster senza dover ridistribuire o ricompilare l'intera applicazione in Kubernetes ogni volta che vengono apportate modifiche.

Nota

Telepresence è un progetto OPEN SOURCE DIF. Microsoft non offre supporto per problemi che potrebbero verificarsi con telepresenza. Se si verificano problemi durante l'uso della telepresenza, visitare la pagina relativa al problema di GitHub di telepresence e aprire un problema.

In questa esercitazione si connette un cluster del servizio Azure Kubernetes a Telepresence e quindi si modifica un'applicazione di esempio in esecuzione in locale.

Funzionamento della telepresenza

La telepresenza inserisce gli agenti del traffico nel pod del carico di lavoro come sidecar. Gli agenti del traffico fungono da proxy, reindirizzando il traffico di rete in ingresso e in uscita dal cluster del servizio Azure Kubernetes al computer locale. È quindi possibile sviluppare e testare nell'ambiente locale come se il computer locale si trovasse nel cluster del servizio Azure Kubernetes. Il processo prevede:

Connessione al cluster del servizio Azure Kubernetes a Telepresence.
Specificare il servizio o la distribuzione per cui si vuole intercettare il traffico in ingresso e in uscita e quindi reindirizzare all'ambiente locale.
Esecuzione della versione locale del servizio. La telepresenza connette la versione locale del servizio al cluster tramite il pod proxy.

Prerequisiti

Un cluster servizio Azure Kubernetes. Se non si ha un cluster che è possibile usare per questa esercitazione, crearne uno usando Esercitazione - Creare un cluster servizio Azure Kubernetes (servizio Azure Kubernetes).
Kubectl viene installato e nel percorso nell'ambiente da riga di comando usato per lo sviluppo. Questa esercitazione usa kubectl per gestire il cluster Kubernetes. kubectl è già installato se si usa Azure Cloud Shell. Per installare kubectl in locale, usare il comando az aks install-cli.
Installare Node.js LTS. Eseguire il comando node --version per verificare che Node.js sia installato.

Connettersi al cluster usando kubectl

Nota

Impostare i valori di $MY_RESOURCE_GROUP_NAME e $MY_AKS_CLUSTER_NAME di conseguenza.

Prima di installare Telepresence e interagire con il cluster del servizio Azure Kubernetes, assicurarsi di essere connessi al cluster. Se non è stato installato kubectl nella sezione Prerequisiti , eseguire questa operazione prima di continuare.

Configurare per connettersi al cluster del servizio Azure Kubernetes kubectl usando il comando az aks get-credentials . Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarli.
```
az aks get-credentials --resource-group $MY_RESOURCE_GROUP_NAME --name $MY_AKS_CLUSTER_NAME
```
Verificare la connessione al cluster usando il comando kubectl cluster-info . Questo comando visualizza il nome del cluster in modo da poter confermare di essere connessi al cluster con cui si vuole lavorare.
```
kubectl cluster-info
```

Clonare l'app di esempio e distribuirla nel cluster del servizio Azure Kubernetes

L'app aks-store-demo usata in questa esercitazione è un'app front-store di base che include le distribuzioni e i servizi Kubernetes seguenti:

Front-store: applicazione Web per i clienti per visualizzare i prodotti ed effettuare ordini.
Servizio prodotto: mostra le informazioni sul prodotto.
Servizio ordini: effettua ordini.
Rabbit MQ: coda di messaggi per una coda di ordini.

Usare git per clonare l'applicazione di esempio nell'ambiente di sviluppo.
```
git clone https://github.com/Azure-Samples/aks-store-demo.git
```
Passare alla directory clonata.
```
cd aks-store-demo
```
Distribuire l'app nel cluster del servizio Azure Kubernetes.
```
kubectl apply -f aks-store-quickstart.yaml
```

Installare Telepresence

Per intercettare il traffico da e verso il cluster del servizio Azure Kubernetes, è necessario installare il client telepresence nel computer locale e gestione traffico nel cluster del servizio Azure Kubernetes.

Installare il client telepresence

Scegliere il sistema operativo in uso nel computer locale e installare tale versione di Telepresence.

Per istruzioni sull'installazione, vedere la documentazione di Telepresence.

Installare Gestione traffico telepresence

Per instradare il traffico cloud al computer locale, Telepresence usa una gestione traffico. Helm viene usato per distribuire Gestione traffico nel cluster Kubernetes.

telepresence helm install

Intercettare il traffico verso il servizio

Completare i passaggi seguenti per intercettare il traffico che passa al servizio nel cluster del servizio Azure Kubernetes e instradarlo al computer locale.

Dalla riga di comando nel computer locale eseguire telepresence connect per connettersi al cluster del servizio Azure Kubernetes e al server API Kubernetes.
```
telepresence connect
```
Una risposta con esito positivo da telepresence connect mostra il nome del cluster e lo spazio dei nomi predefinito a cui telepresence è connesso, simile all'esempio seguente.
```
Connected to context myAKSCluster, namespace default (https://myAKSCluster-dns-ck7w5t5h.hcp.eastus2.azmk8s.io:443)
```

Usare il telepresence list comando per visualizzare un elenco dei servizi che è possibile intercettare.

telepresence list

Una risposta con esito positivo visualizza i servizi disponibili, in modo analogo all'esempio seguente.

order-service  : ready to intercept (traffic-agent not yet installed)
product-service: ready to intercept (traffic-agent not yet installed)
rabbitmq       : ready to intercept (traffic-agent not yet installed)
store-front    : ready to intercept (traffic-agent not yet installed)

Trovare il nome della porta da cui è necessario intercettare il traffico tramite kubectl get service service-name --output yaml. Per questa esercitazione, immettere il comando seguente nella riga di comando.
```
kubectl get service store-front -ojsonpath='{.spec.ports[0].port}'
```
In questo esempio viene restituita la porta da intercettare, 80.
```
80
```
Intercettare il traffico dal servizio nel cluster del servizio Azure Kubernetes usando il telepresence intercept comando con il formato seguente: $ telepresence intercept <service-name> --port <local-port>[:<remote-port>] --env-file <path-to-env-file>
- --port specifica la porta locale e la porta remota per il cluster del servizio Azure Kubernetes.
- --env-file specifica il percorso in cui Telepresence crea un file env contenente le variabili di ambiente necessarie per intercettare il traffico. Questo file deve esistere per intercettare correttamente il traffico del servizio verso il computer locale. Se un file non esiste, la telepresenza lo crea automaticamente.
Nota

sshfs è necessario affinché i montaggi del volume funzionino correttamente durante le intercettazioni per le versioni linux e macOS di Telepresence. Se non è installato, vedere la documentazione di Telepresence per altre informazioni.

Per questa esercitazione, immettere il comando seguente per intercettare il traffico.
```
cd src/store-front
telepresence intercept store-front --port 8080:80 --env-file .env
```
Una risposta con esito positivo visualizza le connessioni che Telepresence intercetta, come nell'esempio seguente.
```
Using Deployment store-front
Intercept name         : store-front
State                  : ACTIVE
Workload kind          : Deployment
Destination            : 127.0.0.1:8080
Service Port Identifier: 80/TCP
Volume Mount Point     : /tmp/telfs-3392425241
Intercepting           : all TCP connections
```

Modificare il codice locale e visualizzare le modifiche in tempo reale

Con telepresence configurato, è possibile modificare facilmente il codice locale e visualizzare le modifiche riflesse in tempo reale. In questo modo è possibile testare ed eseguire il debug in locale sfruttando il cluster del servizio Azure Kubernetes.

Esplorare e aprire components/TopNav.Vue nell'applicazione clonata in precedenza.

Modificare l'elemento di Products spostamento in New Products, come illustrato nell'esempio seguente e salvare le modifiche.

<template>
  <nav>
    <div class="logo">
      <router-link to="/">
        <img src="/contoso-pet-store-logo.png" alt="Contoso Pet Store Logo" />
      </router-link>
    </div>
    <button class="hamburger" @click="toggleNav">
      <span class="hamburger-icon"></span>
    </button>
    <ul class="nav-links" :class="{ 'nav-links--open': isNavOpen }">
      <li><router-link to="/" @click="closeNav">Products</router-link></li>
      <li>
        <router-link to="/cart" @click="closeNav">Cart ({{ cartItemCount }})</router-link>
      </li>
    </ul>
  </nav>
</template>

Eseguire i comandi seguenti per eseguire l'app in locale.
1. npm install - Installa le dipendenze.
2. npm run serve - Avvia il server di sviluppo.

Quando si passa all'indirizzo IP pubblico del store-front servizio nel cluster del servizio Azure Kubernetes, la navigazione aggiornata è presente e il traffico viene instradato alla versione in esecuzione locale del servizio. Le modifiche locali vengono riflesse in tempo reale e interagiscono con altri servizi nel cluster del servizio Azure Kubernetes.

Demo video

Il video seguente fornisce una procedura dettagliata chiara e concisa delle funzionalità di debug F5 di Telepresence.

Passaggio successivo

Questa esercitazione illustra come usare Telepresence con un'applicazione di esempio nel servizio Azure Kubernetes. La telepresenza offre una documentazione più approfondita sul proprio sito Web. Il contenuto include domande frequenti, risoluzione dei problemi, riferimento tecnico, concetti di base, esercitazioni e collegamenti alla community.