ProHoster > Blog > Administración > Preparando unha solicitude para Istio

Preparando unha solicitude para Istio

Preparando unha solicitude para Istio

Istio é unha ferramenta conveniente para conectar, protexer e supervisar aplicacións distribuídas. Istio usa unha variedade de tecnoloxías para executar e xestionar software a escala, incluíndo contedores para empaquetar código de aplicación e dependencias para a súa implantación, e Kubernetes para xestionar eses contedores. Polo tanto, para traballar con Istio hai que coñecer como funciona unha aplicación con múltiples servizos baseada nestas tecnoloxías sen Istio. Se estas ferramentas e conceptos xa che son familiares, non dubides en omitir este tutorial e ir directamente á sección Instalando Istio en Google Kubernetes Engine (GKE) ou instalar unha extensión Istio en GKE.

Esta é unha guía paso a paso na que percorreremos todo o proceso desde o código fonte ata o contedor de GKE para darche unha comprensión básica destas tecnoloxías a través dun exemplo. Tamén verás como Istio aproveita o poder destas tecnoloxías. Isto supón que non sabes nada sobre contenedores, Kubernetes, mallas de servizo ou Istio.

tarefas

Neste tutorial, realizará as seguintes tarefas:

  1. Aprendendo unha sinxela aplicación Hello World con múltiples servizos.
  2. Executar a aplicación desde o código fonte.
  3. Envasado da aplicación en envases.
  4. Creando un clúster de Kubernetes.
  5. Implantación de contedores nun clúster.

Antes de comezar

Siga as instrucións para activar a API de Kubernetes Engine:

  1. Vaia a Páxina de Kubernetes Engine na consola de Google Cloud Platform.
  2. Crea ou selecciona un proxecto.
  3. Agarde ata que se habiliten a API e os servizos relacionados. Isto pode levar uns minutos.
  4. Asegúrate de que a facturación estea configurada para o teu proxecto de Google Cloud Platform. Obtén información sobre como activar a facturación.

Neste tutorial, podes usar Cloud Shell, que prepara a máquina virtual g1-small en Google Compute Engine con Linux baseado en Debian, ou un ordenador Linux ou macOS.

Opción A: Usando Cloud Shell

Beneficios de usar Cloud Shell:

  • Contornas de desenvolvemento Python 2 e Python 3 (incluíndo virtualenv) están totalmente configurados.
  • Ferramentas de liña de comandos gcloud, docker, ir и kubectl, que usaremos xa están instalados.
  • Tes varios para escoller editores de texto:
    1. Editor de código, que se abre coa icona de edición na parte superior da xanela de Cloud Shell.
    2. Emacs, Vim ou Nano, que se abren desde a liña de comandos en Cloud Shell.

Usar Cloud Shell:

  1. Vaia á consola GCP.
  2. Fai clic no botón Activar Cloud Shell (Activar Cloud Shell) na parte superior da xanela da consola GCP.

Preparando unha solicitude para Istio

Na parte baixa Consola GCP Abrirase unha sesión de Cloud Shell cunha liña de comandos nunha nova xanela.

Preparando unha solicitude para Istio

Opción B: Usando as ferramentas de liña de comandos localmente

Se traballarás nun ordenador con Linux ou macOS, terás que configurar e instalar os seguintes compoñentes:

  1. Personalizar Entorno de desenvolvemento Python 3 e Python 2.

  2. Instala Cloud SDK coa ferramenta de liña de comandos gcloud.

  3. Conxunto kubectl - Ferramenta de liña de comandos para traballar Kubernetes.

    gcloud components install kubectl

  4. Conxunto Docker Community Edition (CE). Usará a ferramenta de liña de comandos dockerpara crear imaxes de contedores para a aplicación de mostra.

  5. Instala a ferramenta Control de versións de Gitpara obter a aplicación de mostra de GitHub.

Descargar código de mostra

  1. Descarga o código fonte ola servidor:

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

  2. Vaia ao directorio de código de exemplo:

    cd istio-samples/sample-apps/helloserver

Explorando unha aplicación con múltiples servizos

A aplicación de exemplo está escrita en Python e consta de dous compoñentes que interactúan usando DESCANSO:

  • servidor: servidor sinxelo cun punto final GET, /, que imprime "hola mundo" na consola.
  • cargagen: script que envía tráfico a servidor, cun número configurable de solicitudes por segundo.

Preparando unha solicitude para Istio

Execución dunha aplicación desde o código fonte

Para explorar a aplicación de mostra, execútaa en Cloud Shell ou no teu ordenador.
1) No catálogo istio-samples/sample-apps/helloserver correr servidor:

python3 server/server.py

No inicio servidor móstrase o seguinte:

INFO:root:Starting server...

2) Abre outra xanela de terminal para enviar solicitudes servidor. Se estás a usar Cloud Shell, fai clic na icona de engadir para abrir outra sesión.
3) Enviar unha solicitude a servidor:

curl http://localhost:8080

respostas do servidor:

Hello World!

4) Desde o directorio onde descargaches o código de mostra, vai ao directorio que contén cargagen:

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

5) Cree as seguintes variables de ambiente:

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

6) Corre virtualenv:

virtualenv --python python3 env

7) Activa o entorno virtual:

source env/bin/activate

8) Establecer requisitos para cargagen:

pip3 install -r requirements.txt

9) Corre cargagen:

python3 loadgen.py

No inicio cargagen mostra algo así como a seguinte mensaxe:

Starting loadgen: 2019-05-20 10:44:12.448415
5 request(s) complete to http://localhost:8080

Noutra xanela de terminal servidor envía as seguintes mensaxes á 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 a perspectiva da rede, toda a aplicación execútase nun único host (ordenador local ou máquina virtual Cloud Shell). Polo tanto podes usar localhostpara enviar solicitudes a servidor.
10) Parar cargagen и servidor, entra Ctrl-c en cada xanela de terminal.
11) Na xanela do terminal cargagen desactivar o entorno virtual:

deactivate

Envasado dunha aplicación en envases

Para executar a aplicación en GKE, cómpre empaquetar a aplicación de mostra − servidor и cargagen - dentro Contenedores. Un contedor é unha forma de empaquetar unha aplicación para illala do seu entorno.

Para empaquetar unha aplicación nun contenedor, é necesario dockerfile. dockerfile é un ficheiro de texto que define comandos para construír o código fonte da aplicación e as súas dependencias Imaxe de Docker. Unha vez construída, carga a imaxe nun rexistro de contedores como Docker Hub ou Rexistro de contedores.

O exemplo xa ten dockerfile para servidor и cargagen con todos os comandos necesarios para recoller imaxes. Abaixo - 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/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

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

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.7/ /usr/local/lib/python3.7/

# Add the application
COPY . .

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

  • Equipo FROM python:3-slim como base di a Docker que use o último Imaxe de Python 3 como base.
  • Equipo COPIAR. . copia os ficheiros de orixe no directorio de traballo actual (só no noso caso servidor.py) ao sistema de ficheiros do contedor.
  • PUNTO DE ENTRADA define o comando que se usa para iniciar o contedor. No noso caso, este comando é case o mesmo que o que adoitaba executar servidor.py desde o código fonte.
  • Equipo EXPOÑER indica que servidor agarda os datos a través do porto 8080. Este equipo non proporciona portos. Este é algún tipo de documentación que se necesita para abrir o porto 8080 ao iniciar o recipiente.

Preparándose para contener a súa aplicación

1) Establece as seguintes variables de ambiente. Substituír PROXECT_ID ao ID do teu proxecto GCP.

export PROJECT_ID="PROJECT_ID"

export GCR_REPO="preparing-istio"

Usando valores PROXECT_ID и GCR_REPO etiquetas a imaxe de Docker cando a creas e pásaa a un rexistro de contedores privado.

2) Establece o proxecto GCP predeterminado para a ferramenta de liña de comandos gcloud.

gcloud config set project $PROJECT_ID

3) Establece a zona predeterminada para a ferramenta de liña de comandos gcloud.

gcloud config set compute/zone us-central1-b

4) Asegúrese de que o servizo Container Registry estea activado no proxecto GCP.

gcloud services enable containerregistry.googleapis.com

Servidor de contenedores

  1. Vaia ao directorio onde se atopa o exemplo servidor:

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

  2. Monta a imaxe usando dockerfile e as variables de ambiente que definiu anteriormente:

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

Parámetro -t representa a etiqueta Docker. Este é o nome da imaxe que usas ao implementar o contedor.

  1. Carga a imaxe no Rexistro de Containers: 
    docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Containerización de loadgen

1) Vaia ao directorio onde se atopa o exemplo cargagen:

cd ../loadgen

2) Recolle a imaxe:

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

3) Cargue a imaxe no Rexistro de Containers:

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

Ver unha lista de imaxes

Revisa a lista de imaxes do repositorio e verifica que as imaxes foron cargadas:

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

O comando mostra os nomes das imaxes recentemente cargadas:

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

Creando un clúster de GKE.

Estes contedores poderían executarse nunha máquina virtual Cloud Shell ou nun ordenador co comando executar docker. Pero nun ambiente de produción, necesitas unha forma de orquestrar os contedores de forma centralizada. Por exemplo, necesitas un sistema que se asegure de que os contedores estean sempre funcionando e necesitas un xeito de ampliar e aumentar as instancias de contedores adicionais se o tráfico aumenta.

Para executar aplicacións en contenedores pode usar G.K.E.. GKE é unha plataforma de orquestración de contedores que agrega máquinas virtuais nun clúster. Cada máquina virtual chámase nodo. Os clústeres de GKE baséanse no sistema de xestión de clústeres de código aberto Kubernetes. Kubernetes proporciona mecanismos para interactuar co clúster.

Creando un clúster de GKE:

1) Crear un clúster:

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

Equipo gcloud crea un clúster listo no proxecto GCP e na zona predeterminada que especificaches. Para executar Istio, recomendamos ter polo menos 4 nodos e unha máquina virtual n1-estándar-2.

O equipo crea o clúster en poucos minutos. Cando o clúster está listo, o comando mostra algo así mensaxe.

2) Proporcione credenciais na ferramenta de liña de comandos kubectlpara usalo para xestionar o clúster:

gcloud container clusters get-credentials istioready

3) Agora podes comunicarte con Kubernetes a través de kubectl. Por exemplo, o seguinte comando pode descubrir o estado dos nodos:

kubectl get nodes

O comando produce unha lista de nós:

NAME                                       STATUS   ROLES    AGE    VERSION
gke-istoready-default-pool-dbeb23dc-1vg0   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-36z5   Ready    <none>   100s   v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-fj7s   Ready    <none>   99s    v1.13.6-gke.13
gke-istoready-default-pool-dbeb23dc-wbjw   Ready    <none>   99s    v1.13.6-gke.13

Conceptos clave de Kubernetes

O diagrama mostra unha aplicación en GKE:

Preparando unha solicitude para Istio

Antes de implementar contedores en GKE, aprende os conceptos clave de Kubernetes. Hai ligazóns ao final se queres saber máis.

  • Nodos e clusters. En GKE, un nodo é unha máquina virtual. Noutras plataformas Kubernetes, un nodo pode ser un ordenador ou unha máquina virtual. Un clúster é unha colección de nodos que se poden considerar unha única unidade onde se implementa unha aplicación en contedores.
  • Vainas. En Kubernetes, os contedores execútanse en pods. Un Pod en Kubernetes é unha unidade indivisible. Un Pod contén un ou máis recipientes. Despregas contedores de servidor e cargagen en vainas separadas. Cando hai varios contedores nun pod (por exemplo, un servidor de aplicacións e servidor proxy), os contedores xestionanse como unha única entidade e comparten recursos de pod.
  • Despregamentos. En Kubernetes, unha implementación é un obxecto que é unha colección de pods idénticos. O despregamento lanza varias réplicas de pods distribuídos en nodos do clúster. A implantación substitúe automaticamente os pods que fallaron ou que non responden.
  • Servizo Kubernetes. Ao executar o código da aplicación en GKE, a conexión entre cargagen и servidor. Cando iniciaches os servizos nunha máquina virtual ou nun escritorio de Cloud Shell, enviabas solicitudes a servidor en localhost: 8080. Unha vez implantados en GKE, os pods execútanse nos nós dispoñibles. De xeito predeterminado, non tes control sobre en que nodo se está a executar o pod, polo que ti vainas sen enderezos IP permanentes.
    Para obter un enderezo IP para servidor, cómpre definir unha abstracción de rede encima dos pods. Iso é o que é Servizo Kubernetes. O servizo Kubernetes ofrece un punto final persistente para un conxunto de pods. Hai uns cantos tipos de servizos. servidor usos LoadBalancer, que proporciona un enderezo IP externo para contactar servidor desde fóra do clúster.
    Kubernetes tamén ten un sistema DNS integrado que asigna nomes DNS (por exemplo, helloserver.default.cluster.local) Servizos. Grazas a isto, os pods do clúster comunícanse con outros pods do clúster nun enderezo constante. O nome DNS non se pode usar fóra do clúster, como en Cloud Shell ou nun ordenador.

Kubernetes maniféstase

Cando executou a aplicación desde a orixe, utilizou o comando imperativo python3

servidor.py

O imperativo implica un verbo: "facer isto".

Utiliza Kubernetes modelo declarativo. Isto significa que non estamos dicindo a Kubernetes exactamente o que debe facer, senón que describimos o estado desexado. Por exemplo, Kubernetes inicia e detén os pods segundo sexa necesario para manter o estado real do sistema coherente co estado desexado.

Indica o estado desexado en manifestos ou ficheiros YAML. Un ficheiro YAML contén especificacións para un ou máis obxectos de Kubernetes.

O exemplo contén un ficheiro YAML para servidor и cargagen. Cada ficheiro YAML especifica o estado desexado do obxecto de implementación e do servizo Kubernetes.

servidor.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 o tipo de obxecto.
  • metadatos.nome especifica o nome da implantación.
  • Primeiro campo especificación contén unha descrición do estado desexado.
  • espec.réplicas indica o número desexado de vainas.
  • Sección especificación.modelo define un modelo de pod. Hai un campo na especificación do pod imaxe, que especifica o nome da imaxe que se debe extraer do Rexistro de contedores.

O servizo defínese do seguinte xeito:

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

  • LoadBalancer: os clientes envían solicitudes ao enderezo IP do equilibrador de carga, que ten un enderezo IP persistente e é accesible desde fóra do clúster.
  • targetPort: como lembrades, o equipo EXPOSICIÓN 8080 в dockerfile non proporcionou portos. Vostede proporciona o porto 8080para que poidas contactar co contedor servidor fóra do clúster. No noso caso hellosvc.default.cluster.local:80 (nome abreviado: ola vc) corresponde ao porto 8080 Enderezos IP do pod ola servidor.
  • porto: Este é o número de porto onde outros servizos do clúster enviarán solicitudes.

loadgen.yaml

Obxecto de implantación loadgen.yaml semella servidor.yaml. A diferenza é que o obxecto de implementación contén unha sección aprox. Define as variables de ambiente que son necesarias cargagen e que instalou ao executar a aplicación desde a orixe.

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

Tempo cargagen non acepta solicitudes entrantes, para o campo tipo indicado ClústerIP. Este tipo proporciona un enderezo IP persistente que poden usar os servizos do clúster, pero este enderezo IP non está exposto a clientes externos.

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

Implementación de contedores en GKE

1) Vaia ao directorio onde se atopa o exemplo servidor:

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

2) Aberto servidor.yaml nun editor de texto.
3) Substitúe o nome no campo imaxe ao nome da túa imaxe de Docker.

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

Substituír PROXECT_ID ao ID do teu proxecto GCP.
4) Garda e pecha servidor.yaml.
5) Desplegue o ficheiro YAML en Kubernetes:

kubectl apply -f server.yaml

Despois de completar con éxito, o comando produce o seguinte código:

deployment.apps/helloserver created
service/hellosvc created

6) Vaia ao directorio onde cargagen:

cd ../loadgen

7) Aberto loadgen.yaml nun editor de texto.
8) Substitúe o nome no campo imaxe ao nome da túa imaxe de Docker.

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

Substituír PROXECT_ID ao ID do teu proxecto GCP.
9) Garda e pecha loadgen.yaml, pecha o editor de texto.
10) Desplegue o ficheiro YAML en Kubernetes:

kubectl apply -f loadgen.yaml

Despois de completar con éxito, o comando produce o seguinte código:

deployment.apps/loadgenerator created
service/loadgensvc created

11) Comproba o estado das vainas:

kubectl get pods

O comando mostra o estado:

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

12) Extrae os rexistros de aplicacións do pod cargagen. Substituír POD_ID ao identificador da resposta anterior.

kubectl logs loadgenerator-POD_ID

13) Obter enderezos IP externos ola vc:

kubectl get service

A resposta do comando é algo 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      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

14) Enviar unha solicitude a ola vc: substituír EXTERNAL_IP ao enderezo IP externo ola vc.

curl http://EXTERNAL_IP

Afrontemos a Istio

Xa tes unha aplicación implantada en GKE. cargagen pode usar Kubernetes DNS (ola: 80) para enviar solicitudes servidore pode enviar solicitudes a servidor por dirección IP externa. Aínda que Kubernetes ten moitas funcións, falta algunha información sobre os servizos:

  • Como interactúan os servizos? Cales son as relacións entre servizos? Como circula o tráfico entre os servizos? Vostede é consciente diso cargagen envía solicitudes a servidor, pero imaxina que non sabes nada da aplicación. Para responder a estas preguntas, vexamos a lista de pods en execución en GKE.
  • Métricas. Canto tempo servidor responde a unha solicitude entrante? Cantas solicitudes por segundo recibe o servidor? Dá mensaxes de erro?
  • Información de seguridade. Tráfico entre cargagen и servidor só pasa HTTP ou por mTLS?

Istio responde a todas estas preguntas. Para iso, Istio coloca un proxy sidecar enviado en cada vaina. O proxy Envoy intercepta todo o tráfico entrante e saínte aos contedores de aplicacións. Quere dicir que servidor и cargagen recibir a través do proxy sidecar Envoy e todo o tráfico desde cargagen к servidor pasa polo proxy Envoy.

As conexións entre os proxies de Envoy forman unha malla de servizo. A arquitectura de malla de servizo ofrece unha capa de control encima de Kubernetes.

Preparando unha solicitude para Istio

Dado que os proxys de Envoy se executan nos seus propios contedores, Istio pódese instalar encima dun clúster de GKE sen case cambios no código da aplicación. Pero fixeches un traballo para preparar a túa aplicación para ser xestionada por Istio:

  • Servizos para todos os contedores. Aos despregamentos servidor и cargagen vinculado ao servizo Kubernetes. Mesmo cargagen, que non recibe solicitudes entrantes, existe un servizo.
  • Os portos dos servizos deben ter nomes. Aínda que os portos de servizo poden deixarse ​​sen nome en GKE, Istio require que o especifique nome do porto de acordo co seu protocolo. No ficheiro YAML o porto para servidor chamado httpporque o servidor usa o protocolo HTTP... Se servizo usado gRPC, nomearías o porto grpc.
  • Os despregamentos están marcados. Polo tanto, pode utilizar as funcións de xestión de tráfico de Istio, como dividir o tráfico entre versións do mesmo servizo.

Instalación

Hai dúas formas de instalar Istio. Pode habilite Istio na extensión de GKE ou instalar a versión de código aberto de Istio no clúster. Con Istio en GKE, podes xestionar facilmente as instalacións e as actualizacións de Istio ao longo do ciclo de vida do clúster de GKE. Se queres a última versión de Istio ou máis control sobre a configuración do teu panel de control de Istio, instala a versión de código aberto en lugar da extensión Istio en GKE. Para decidir sobre o enfoque, le o artigo Necesito Istio en GKE?.

Seleccione unha opción, revise a guía adecuada e siga as instrucións para instalar Istio no seu clúster. Se queres usar Istio coa túa aplicación recentemente implantada, habilitar a implementación de sidecar para o espazo de nomes defecto.

Limpeza

Para evitar que te cobren na túa conta de Google Cloud Platform os recursos que utilizaches neste titorial, elimina o clúster de contedores unha vez que teñas instalado Istio e xogas coa aplicación de mostra. Isto eliminará todos os recursos do clúster, como instancias de cálculo, discos e recursos de rede.

Cal é o próximo?

Fonte: www.habr.com

Engadir un comentario