🥇Preparación de la aplicación para Istio

Istio es una herramienta conveniente para conectar, proteger y monitorear aplicaciones distribuidas. En Istio se utilizan diferentes tecnologías para implementar y gestionar software a gran escala, incluyendo contenedores para empaquetar el código de la aplicación y sus dependencias para la implementación, y Kubernetes para gestionar esos contenedores. Por lo tanto, para trabajar con Istio, debe saber cómo funciona una aplicación con múltiples servicios basada en estas tecnologías. sin Istio. Si ya le son familiares estas herramientas y conceptos, siéntase libre de omitir esta guía y pasar directamente a la sección. Instalación de Istio en Google Kubernetes Engine (GKE) o instalar la extensión Istio en GKE.

Esta es una guía paso a paso donde revisaremos todo el proceso desde el código fuente hasta el contenedor en GKE, para que obtenga una comprensión básica de estas tecnologías a través de un ejemplo. También verá cómo Istio aprovecha las capacidades de estas tecnologías. Suponemos que no sabe nada sobre contenedores, Kubernetes, service mesh o Istio.

Tareas

En esta guía realizará las siguientes tareas:

Explorar una aplicación hello world con múltiples servicios.
Ejecutar la aplicación desde el código fuente.
Empaquetar la aplicación en contenedores.
Crear un clúster de Kubernetes.
Desplegar contenedores en el clúster.

Antes de comenzar

Siga las instrucciones para habilitar la API de Kubernetes Engine:

Vaya a la página de Kubernetes Engine en la consola de Google Cloud Platform.
Cree o seleccione un proyecto.
Espere a que se habiliten la API y los servicios relacionados. Esto puede tardar varios minutos.
Asegúrese de que la facturación esté configurada para el proyecto de Google Cloud Platform. Aprenda cómo habilitar la facturación.

En esta guía, puede usar Cloud Shell, que prepara una máquina virtual g1-small en Google Compute Engine con Linux basado en Debian, o una computadora con Linux o macOS.

Opción A: uso de Cloud Shell

Ventajas de usar Cloud Shell:

Los entornos de desarrollo de Python 2 y Python 3 (incluyendo virtualenv) están completamente configurados.
Las herramientas de línea de comandos gcloud, docker, git y kubectl, que utilizaremos, ya están instaladas.
Tiene varias opciones de editors de texto:
1. El editor de código, que se abre con el icono de edición en la parte superior de la ventana de Cloud Shell.
2. Emacs, Vim o Nano, que se abren desde la línea de comandos en Cloud Shell.

Para usar Cloud Shell:

Vaya a la consola de GCP.
Haga clic en el botón Active Cloud Shell (Activar Cloud Shell) en la parte superior de la ventana de la consola de GCP.

En la parte inferior de la consola de GCP se abrirá una sesión de Cloud Shell con la línea de comandos en una nueva ventana.

Opción B: usar herramientas de línea de comandos localmente

Si va a trabajar en una computadora con Linux o macOS, debe configurar e instalar los siguientes componentes:

Configura un entorno de desarrollo de Python 3 y Python 2.
Instalar Cloud SDK con la herramienta de línea de comandos gcloud.
Instala kubectl — la herramienta de línea de comandos para trabajar con Kubernetes.
```
gcloud components install kubectl
```
Instala Docker Community Edition (CE). Usará la herramienta de línea de comandos docker, para crear imágenes de contenedores para el ejemplo de aplicación.
Instale la herramienta de control de versiones Git, para obtener el ejemplo de aplicación desde GitHub.

Descargar el ejemplo de código

Descargue el código fuente helloserver:

git clone https://github.com/GoogleCloudPlatform/istio-samples

Navegue hasta el directorio del ejemplo de código:
```
cd istio-samples/sample-apps/helloserver
```

Explorando la aplicación con varios servicios

El ejemplo de aplicación está escrito en Python y consta de dos componentes que interactúan a través de REST:

servidor: un servidor simple con un único punto final GET, /, que imprime 'hello world' en la consola.
loadgen: un script que envía tráfico a servidor, con un número configurable de solicitudes por segundo.

Ejecutar la aplicación desde el código fuente

Para explorar el ejemplo de aplicación, ejecútelo en Cloud Shell o en su computadora.
1) En el directorio istio-samples/sample-apps/helloserver ejecute servidor:

python3 server/server.py

Al iniciar servidor se mostrará lo siguiente:

INFO:root:Starting server...

2) Abra otra ventana de terminal para enviar solicitudes a servidor. Si está utilizando Cloud Shell, haga clic en el ícono de agregar para abrir otra sesión.
3) Envíe una solicitud a servidor:

curl http://localhost:8080

el servidor responde:

¡Hola Mundo!

4) Desde el directorio donde descargó el ejemplo de código, cambie al directorio que contiene loadgen:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/loadgen

5) Cree las siguientes variables de entorno:

export SERVER_ADDR=http://localhost:8080
export REQUESTS_PER_SECOND=5

6) Ejecute virtualenv:

virtualenv --python python3 env

7) Active el entorno virtual:

source env/bin/activate

8) Instale los requisitos para loadgen:

pip3 install -r requirements.txt

9) Ejecute loadgen:

python3 loadgen.py

Al iniciar loadgen imprimirá aproximadamente el siguiente mensaje:

Iniciando loadgen: 2019-05-20 10:44:12.448415
5 solicitud(es) completadas a http://localhost:8080

En otra ventana de terminal servidor imprimirá aproximadamente los siguientes mensajes en la consola:

127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*

Desde la perspectiva de la red, toda la aplicación funciona en un único host (computadora local o máquina virtual Cloud Shell). Por lo tanto, puedes usar localhost, para enviar solicitudes a servidor.
10) Para detener loadgen y servidor, ingresa Ctrl-c en cada ventana de terminal.
11) En la ventana de terminal loadgen desactiva el entorno virtual:

deactivate

Empaquetando la aplicación en contenedores

Para ejecutar la aplicación en GKE, es necesario empaquetar el ejemplo de la aplicación — servidor y loadgen — en contenedores. Un contenedor es una forma de empaquetar la aplicación para aislarla del entorno.

Para empaquetar la aplicación en un contenedor, se necesita Dockerfile. Dockerfile — un archivo de texto que define los comandos para construir el código fuente de la aplicación y sus dependencias en una imagen Docker. Después de construir, cargas la imagen en un registro de contenedores, como Docker Hub o Container Registry.

El ejemplo ya tiene Dockerfile para servidor y loadgen con todos los comandos necesarios para construir las imágenes. A continuación — Dockerfile para servidor:

FROM python:3-slim as base
FROM base as builder
RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        g++ 
    && rm -rf /var/lib/apt/lists/*

# Habilitar registro sin buffer
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update 
    && apt-get install -y --no-install-recommends 
        wget

WORKDIR /helloserver

# Obtener paquetes del constructor
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Agregar la aplicación
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

Comando FROM python:3-slim as base indica a Docker que use la última imagen de Python 3 como base.
Comando COPY . . copia los archivos fuente al directorio de trabajo actual (en nuestro caso, solo server.py) en el sistema de archivos del contenedor.
ENTRYPOINT define el comando que se utiliza para ejecutar el contenedor. En nuestro caso, este comando es casi idéntico al que usaste para ejecutar server.py desde el código fuente.
Comando EXPOSE indica que servidor espera datos a través del puerto 8080. Este comando no proporciona puertos.Es algo así como una documentación que se necesita para abrir el puerto 8080 al iniciar el contenedor.

Preparación para la contenedorización de la aplicación

1) Establecer las siguientes variables de entorno. Reemplace PROJECT_ID por el identificador de su proyecto GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Con los valores de PROJECT_ID y GCR_REPO marcas la imagen de Docker al construirla y enviarla al registro privado de Container Registry.

2) Establecer el proyecto GCP por defecto para la herramienta de línea de comandos gcloud.

gcloud config set project $PROJECT_ID

3) Establecer la zona por defecto para la herramienta de línea de comandos gcloud.

gcloud config set compute/zone us-central1-b

4) Asegúrate de que el servicio Container Registry esté habilitado en el proyecto de GCP.

gcloud services enable containerregistry.googleapis.com

Contenerización del servidor

Vaya al directorio donde se encuentra el ejemplo servidor:

cd SU_DIRECTORIO_DE_TRABAJO/istio-samples/sample-apps/helloserver/server/

Construya la imagen usando Dockerfile y las variables de entorno que definió anteriormente:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```

Parámetro -t representa la etiqueta de Docker. Este es el nombre de la imagen que usa al desplegar el contenedor.

Envíe la imagen al Container Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Contenerización del loadgen

1) Vaya al directorio donde se encuentra el ejemplo loadgen:

cd ../loadgen

2) Construya la imagen:

docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

3) Envíe la imagen al Container Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

Visualización de la lista de imágenes

Revise la lista de imágenes en el repositorio y asegúrese de que las imágenes se hayan enviado:

gcloud container images list --repository gcr.io/$PROJECT_ID/preparing-istio

El comando devuelve los nombres de las imágenes que se acaban de enviar:

NOMBRE
gcr.io/PROJECT_ID/preparing-istio/helloserver
gcr.io/PROJECT_ID/preparing-istio/loadgen

Creación del clúster GKE.

Estos contenedores podrían ejecutarse en una máquina virtual Cloud Shell o en su computadora con el comando docker run. Pero en un entorno de producción se necesita una forma de orquestar contenedores de manera centralizada. Por ejemplo, se requiere un sistema que supervise que los contenedores siempre estén funcionando y una manera de escalar y ejecutar instancias adicionales de contenedores si aumenta el tráfico.

Para ejecutar aplicaciones en contenedores se puede usar GKE. GKE es una plataforma de orquestación de contenedores que agrupa máquinas virtuales en un clúster. Cada máquina virtual se llama nodo. Los clústeres de GKE están basados en el sistema de gestión de clústeres de código abierto Kubernetes. Kubernetes proporciona mecanismos para interactuar con el clúster.

Creación del clúster GKE:

1) Cree un clúster:

gcloud container clusters create istioready 
  --cluster-version latest 
  --machine-type=n1-standard-2 
  --num-nodes 4

Comando gcloud crea el clúster istioready en el proyecto de GCP y en la zona predeterminada que especificó. Para ejecutar Istio, se recomienda tener al menos 4 nodos y una máquina virtual n1-standard-2.

El comando toma unos minutos para crear el clúster. Cuando esté listo, el comando devuelve algo como mensaje.

2) Especifique las credenciales en la herramienta de línea de comandos kubectl, para poder administrar el clúster:

gcloud container clusters get-credentials istioready

3) Ahora se puede comunicar con Kubernetes a través de kubectl. Por ejemplo, con el siguiente comando puede comprobar el estado de los nodos:

kubectl get nodes

El comando devuelve la lista de nodos:

NOMBRE                                       ESTADO   ROLES    EDAD    VERSIÓN
gke-istoready-default-pool-dbeb23dc-1vg0   Listo       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Listo       100s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Listo       99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Listo       99s    v1.13.6-gke.13

Conceptos clave de Kubernetes

El esquema muestra una aplicación en GKE:

Antes de desplegar contenedores en GKE, estudie los conceptos clave de Kubernetes. Al final hay enlaces si desea saber más.

Nodos y clústeres. En GKE, un nodo es una máquina virtual. En otras plataformas, un nodo de Kubernetes puede ser una computadora o una máquina virtual. Un clúster es un conjunto de nodos que se puede considerar como una sola unidad y donde despliega su aplicación en contenedores.
Pods. En Kubernetes, los contenedores se ejecutan en pods. Un pod en Kubernetes es una unidad indivisible. Un pod puede contener uno o varios contenedores. Despliega los contenedores server y loadgen en pods separados. Cuando hay varios contenedores en un pod (por ejemplo, el servidor de la aplicación y servidor proxy), los contenedores se gestionan como un único objeto y comparten los recursos del pod.
Despliegues. En Kubernetes, un despliegue es un objeto que representa un conjunto de pods idénticos. Un despliegue ejecuta varias réplicas de pods, distribuidas entre los nodos del clúster. El despliegue reemplaza automáticamente los pods que fallan o no responden.
Servicio de Kubernetes. Al ejecutar el código de la aplicación en GKE, cambia la conexión entre loadgen y servidor. Cuando ejecutó servicios en una máquina virtual de Cloud Shell o en su computadora, enviaba solicitudes a servidor en la dirección localhost:8080. Tras el despliegue en GKE, los pods se ejecutan en los nodos disponibles. Por defecto, no puede controlar en qué nodo se ejecuta un pod, por lo que tiene pod’s sin direcciones IP permanentes.
Para obtener una dirección IP para servidor, debe definir una abstracción de red sobre los pods. Esto es un servicio de Kubernetes. El servicio de Kubernetes proporciona un punto final permanente para un conjunto de pods. Hay varios tipos de servicios. servidor utiliza LoadBalancer, que proporcionan una dirección IP externa para comunicarse con servidor desde fuera del clúster.
Además, Kubernetes tiene un sistema DNS integrado que asigna nombres DNS (por ejemplo, helloserver.default.cluster.local) servicios. Gracias a esto, los pod dentro del clúster se conectan con otros pod en el clúster a través de una dirección constante. El nombre DNS no se puede utilizar fuera del clúster, por ejemplo, en Cloud Shell o en la computadora.

Manifiestos de Kubernetes

Cuando ejecutaste la aplicación desde el código fuente, utilizaste el comando imperativo python3

server.py

La imperatividad implica un verbo: 'haz esto'.

Kubernetes utiliza modelo declarativo. Esto significa que no le decimos a Kubernetes qué hacer, sino que describimos el estado deseado. Por ejemplo, Kubernetes inicia y detiene los pod según sea necesario para que el estado real del sistema coincida con el deseado.

El estado deseado lo especificas en los manifiestos, o archivos YAML. El archivo YAML contiene las especificaciones para uno o varios objetos de Kubernetes.

En el ejemplo hay un archivo YAML para servidor y loadgen. Cada archivo YAML especifica el estado deseado del objeto de despliegue y del servicio de Kubernetes.

server.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  selector:
    matchLabels:
      app: helloserver
  replicas: 1
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always

tipo indica el tipo de objeto.
metadata.name indica el nombre del despliegue.
El primer campo spec contiene la descripción del estado deseado.
spec.replicas indica el número deseado de pod.
Sección spec.template define la plantilla del pod. En la especificación de los pod, hay un campo image, donde se indica el nombre de la imagen que debe extraerse del Container Registry.

El servicio se define de la siguiente manera:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  type: LoadBalancer
  selector:
    app: helloserver
  ports:
  - name: http
    port: 80
    targetPort: 8080

LoadBalancer: los clientes envían solicitudes a la dirección IP del equilibrador de carga, que tiene una dirección IP constante y es accesible desde fuera del clúster.
targetPort: como recordarás, el comando EXPOSE 8080 en Dockerfile no proporcionaba puertos. Debes proporcionar el puerto 8080, para poder conectarte al contenedor servidor desde fuera del clúster. En nuestro caso, hellosvc.default.cluster.local:80 (nombre corto: hellosvc) corresponde al puerto 8080 dirección IP del pod helloserver.
port: es el número de puerto al que los demás servicios en el clúster enviarán solicitudes.

loadgen.yaml

El objeto de despliegue en loadgen.yaml es similar a server.yaml. La diferencia es que el objeto de despliegue contiene la sección env. Define las variables de entorno que son necesarias loadgen y que configuraste al ejecutar la aplicación desde el código fuente.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  selector:
    matchLabels:
      app: loadgenerator
  replicas: 1
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      terminationGracePeriodSeconds: 5
      restartPolicy: Always
      containers:
      - name: main
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        env:
        - name: SERVER_ADDR
          value: "http://hellosvc:80/"
        - name: REQUESTS_PER_SECOND
          value: "10"
        resources:
          requests:
            cpu: 300m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi

Uno loadgen no acepta solicitudes entrantes, para el campo tipo establecido ClusterIP. Este tipo proporciona una dirección IP estática que puede ser utilizada por los servicios en el clúster, pero esta dirección IP no se proporciona a los clientes externos.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  type: ClusterIP
  selector:
    app: loadgenerator
  ports:
  - name: http
    port: 80
    targetPort: 8080

Despliegue de contenedores en GKE

1) Vaya al directorio donde se encuentra el ejemplo servidor:

cd SU_DIRECTORIO_DE_TRABAJO/istio-samples/sample-apps/helloserver/server/

2) Abra server.yaml en un editor de texto.
3) Reemplace el nombre en el campo image con el nombre de su imagen de Docker.

image: gcr.io/PROJECT_ID/preparing-istio/helloserver:v0.0.1

Reemplace PROJECT_ID con el identificador de su proyecto GCP.
4) Guarde y cierre server.yaml.
5) Despliegue el archivo YAML en Kubernetes:

kubectl apply -f server.yaml

Después de completarse con éxito, el comando emite el siguiente código:

deployment.apps/helloserver created
service/hellosvc created

6) Vaya al directorio donde se encuentra loadgen:

cd ../loadgen

7) Abra loadgen.yaml en un editor de texto.
8) Reemplace el nombre en el campo image con el nombre de su imagen de Docker.

image: gcr.io/PROJECT_ID/preparing-istio/loadgenv0.0.1

Reemplace PROJECT_ID con el identificador de su proyecto GCP.
9) Guarde y cierre loadgen.yaml, cierre el editor de texto.
10) Despliegue el archivo YAML en Kubernetes:

kubectl apply -f loadgen.yaml

Después de completarse con éxito, el comando emite el siguiente código:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Verifique el estado de los pods:

kubectl get pods

El comando muestra el estado:

NAME                             READY   STATUS    RESTARTS   AGE
helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s

12) Extraiga los registros de la aplicación desde el pod loadgen. Reemplace POD_ID con el identificador de la respuesta anterior.

kubectl logs loadgenerator-POD_ID

13) Obtenga las direcciones IP externas hellosvc:

kubectl get service

La respuesta del comando se ve aproximadamente así:

NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
kubernetes   ClusterIP      10.81.0.1                443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155             80/TCP         4m52s

14) Envíe una solicitud a hellosvc: reemplace EXTERNAL_IP con la dirección IP externa hellosvc.

curl http://EXTERNAL_IP

Pasemos a Istio

Ya tiene una aplicación desplegada en GKE. loadgen puede utilizar el DNS de Kubernetes (hellosvc:80), para enviar solicitudes a servidor, y puede enviar solicitudes a servidor a través de la dirección IP externa. Aunque Kubernetes tiene muchas capacidades, falta cierta información sobre los servicios:

¿Cómo interactúan los servicios? ¿Cuáles son las relaciones entre los servicios? ¿Cómo se realiza el tráfico entre los servicios? ¿Estás al tanto de que loadgen envía solicitudes a servidor, pero imagina que no sabes nada sobre la aplicación. Para responder a estas preguntas, observemos la lista de pods en ejecución en GKE.
Métricas. ¿Cuánto tiempo servidor responde a una solicitud entrante? ¿Cuántas solicitudes por segundo llegan al servidor? ¿Genera mensajes de error?
Información sobre seguridad. El tráfico entre loadgen y servidor pasa simplemente por . La mejora del rendimiento de nginx se debe al uso de una arquitectura asíncrona basada en eventos, a diferencia del modelo multihilo. Esto, junto con un alto paralelismo, permite a nginx manejar solicitudes con un bajo consumo de memoria. Esto hace que Nginx sea una excelente solución para servidores web, tanto para grandes como para pequeños volúmenes de tráfico. nginx es una solución madura y completamente documentada, que permite configurar fácilmente la configuración según tus necesidades. Los desarrolladores también utilizan nginx como proxy inverso para o por mTLS?

Todas estas preguntas las responde Istio. Para ello, Istio coloca un proxy sidecar Envoy en cada pod. El proxy Envoy intercepta todo el tráfico entrante y saliente hacia los contenedores de la aplicación. Esto significa que servidor y loadgen reciben a través del proxy sidecar Envoy, y todo el tráfico de loadgen a servidor pasa a través del proxy Envoy.

Las conexiones entre los proxies Envoy forman una malla de servicios. La arquitectura de la malla de servicios proporciona un nivel de control sobre Kubernetes.

Como el proxy Envoy se ejecuta en sus propios contenedores, Istio se puede instalar sobre el clúster de GKE sin cambiar prácticamente el código de la aplicación. Pero has hecho un esfuerzo para preparar la aplicación para su gestión a través de Istio:

Servicios para todos los contenedores. A los despliegues servidor y loadgen se les asocia un servicio de Kubernetes. Incluso el loadgen, al que no llegan solicitudes entrantes, tiene un servicio.
Los puertos en los servicios deben tener nombres. Aunque en GKE los puertos de los servicios pueden dejarse sin nombre, Istio exige especificar el nombre del puerto de acuerdo con su protocolo. En el archivo YAML, el puerto para servidor se llama http, porque el servidor utiliza el protocolo . La mejora del rendimiento de nginx se debe al uso de una arquitectura asíncrona basada en eventos, a diferencia del modelo multihilo. Esto, junto con un alto paralelismo, permite a nginx manejar solicitudes con un bajo consumo de memoria. Esto hace que Nginx sea una excelente solución para servidores web, tanto para grandes como para pequeños volúmenes de tráfico. nginx es una solución madura y completamente documentada, que permite configurar fácilmente la configuración según tus necesidades. Los desarrolladores también utilizan nginx como proxy inverso para. Si el servicio utilizara gRPC, deberías llamar al puerto grpc.
Los despliegues están etiquetados. Por lo tanto, puedes utilizar las funciones de gestión de tráfico de Istio, como dividir el tráfico entre versiones de un mismo servicio.

Instalación de Istio

Istio se puede instalar de dos maneras. Puedes activar la extensión Istio en GKE o instalar la versión de código abierto de Istio en el clúster. Con Istio en GKE, puedes gestionar fácilmente la instalación y actualización de Istio a lo largo del ciclo de vida del clúster GKE. Si necesitas la versión más nueva de Istio o más control sobre la configuración del panel de control de Istio, instala la versión de código abierto en lugar de la extensión Istio en GKE. Para decidir el enfoque, lee el artículo ¿Necesito Istio en GKE?.

Elige la opción, revisa la guía correspondiente y sigue las instrucciones para instalar Istio en el clúster. Si deseas utilizar Istio con una aplicación recién desplegada, activa la inyección de sidecars para el espacio de nombres default.

Limpiar

Para evitar que se le cobre por los recursos utilizados en esta guía en su cuenta de Google Cloud Platform, elimine el clúster de contenedores una vez que haya instalado Istio y jugado con el ejemplo de la aplicación. Esto eliminará todos los recursos del clúster, incluidos las instancias de cómputo, discos y recursos de red.

¿Qué sigue?

Explore las siguientes tecnologías:
1. Docker
2. Contenedores
3. Container Registry
4. Kubernetes
5. GKE
6. Service mesh
7. Istio
Explore las siguientes herramientas:
Explore los conceptos de Kubernetes:
1. Clústeres
2. Nodos
3. Pods
4. Servicios
5. Despliegue

Fuente: habr.com