Implementa una aplicación sin estado

En esta página, se explica cómo implementar una aplicación sin estado con Google Kubernetes Engine.

Descripción general

Las aplicaciones sin estado son aplicaciones que no almacenan los datos o el estado de la aplicación en el clúster o en almacenamiento continuo. En cambio, los datos y el estado de la aplicación se quedan con el cliente. Esto hace que las aplicaciones sin estado sean más escalables. Por ejemplo, una aplicación frontend no tiene estado: implementas múltiples réplicas para aumentar su disponibilidad y disminuir su escala cuando la demanda es baja, y las réplicas no necesitan identidades únicas.

Kubernetes usa el controlador de Implementación para implementar aplicaciones sin estado como pods uniformes que no son únicos. Las implementaciones administran el estado deseado de tu aplicación: cuántos pods deben ejecutar tu aplicación, qué versión de imagen del contenedor se debe ejecutar, cómo se deben etiquetar los pods, etcétera. El estado deseado puede modificarse de forma dinámica mediante actualizaciones en la especificación del pod de la implementación.

Las aplicaciones sin estado se diferencian de las aplicaciones con estado, que usan almacenamiento continuo para guardar datos y StatefulSets a fin de implementar pods con identidades únicas.

Antes de comenzar

Sigue estos pasos a fin de prepararte para esta tarea:

  • Asegúrate de haber habilitado la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Asegúrate de haber instalado el SDK de Cloud.
  • Establece tu ID del proyecto predeterminado:
    gcloud config set project [PROJECT_ID]
  • Si trabajas con clústeres zonales, establece tu zona de procesamiento predeterminada:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Si trabajas con clústeres regionales, establece tu región de procesamiento predeterminada:
    gcloud config set compute/region [COMPUTE_REGION]
  • Actualiza gcloud a la versión más reciente:
    gcloud components update
  • Asegúrate de que tu aplicación en contenedores se almacene en un registro de imagen, como Container Registry.

  • Si recién comienzas a usar GKE, deberías completar la guía de inicio rápido, en la que habilitarás la API de GKE y aprenderás cómo funciona el producto.

Anatomía de una implementación

A continuación, se muestra un ejemplo de un archivo de manifiesto de una implementación simple. Esta implementación crea tres pods replicados con la etiqueta app=my-app que ejecutan la imagen hello-app almacenada en Container Registry:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      run: my-app
  template:
    metadata:
      labels:
        run: my-app
    spec:
      containers:
      - name: hello-app
        image: gcr.io/google-samples/hello-app:1.0

en el que:

  • spec: replicas: es la cantidad de pods replicados que administra la implementación.
  • spec: template: metadata: labels: es la etiqueta asignada a cada pod, que la implementación usa para administrar los pods.
  • spec: template: spec: es la especificación de pod, que define cómo debe ejecutarse cada pod. spec: containers incluye el nombre del contenedor que se ejecutará en cada pod y la imagen de contenedor que se debe ejecutar.

Para obtener más información sobre la especificación de implementación, consulta la referencia de la API de Deployment.

Crea una implementación

Crea una implementación mediante uno de los siguientes métodos:

  • Puedes usar la característica de implementación en el menú Cargas de trabajo en Google Cloud Platform Console para crear una implementación simple de una imagen de contenedor almacenada en Container Registry.
  • Puedes escribir un manifiesto de implementación y ejecutar kubectl apply para crear el recurso.

kubectl apply

Puedes crear y actualizar de manera declarativa implementaciones desde archivos de manifiesto mediante kubectl apply. Este método también mantiene las actualizaciones realizadas a recursos activos sin transferir los cambios a los archivos de manifiesto.

Para crear una implementación desde su archivo de manifiesto, ejecuta el siguiente comando:

kubectl apply -f [DEPLOYMENT_FILE]

en el que [DEPLOYMENT_FILE] es el archivo de manifiesto, como config.yaml.

También puedes usar kubectl apply -f [DIRECTORY]/ a fin de crear todos los objetos (excepto los existentes) definidos en los archivos de manifiesto almacenados en un directorio.

Console

Para crear una implementación, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. Haz clic en Implementar.

  3. Selecciona lo siguiente en Editar contenedor:

    • Imagen de contenedor existente para elegir una imagen de Docker disponible en Container Registry. Completa Imagen de contenedor con la imagen de contenedor que deseas usar y su versión.

    • Imagen de contenedor nueva para usar una imagen creada con Cloud Source Repositories y Cloud Build.

  4. De manera opcional, configura la implementación con los siguientes elementos:

    • Variables de entorno para pasar al contenedor.
    • Comandos iniciales para personalizar el punto de entrada del contenedor en el entorno de ejecución.
  5. Haz clic en Continuar. Aparecerá la pantalla Configuración.

  6. Proporciona a tu implementación un Nombre de la aplicación y especifica el Espacio de nombres de Kubernetes para implementarlo.

  7. Si deseas aplicar Etiquetas de Kubernetes a la implementación, en Etiquetas agrega Claves y Valores.

  8. Si deseas guardar el YAML que crea esta implementación para actualizarlo más tarde, haz clic en Ver YAML. Copia y pega el YAML en un archivo y, luego, guárdalo.

  9. En el menú desplegable Clúster, selecciona el clúster deseado.

  10. Haz clic en Implementar.

Inspecciona la implementación

Una vez que creaste la implementación, puedes usar uno de los siguientes métodos para inspeccionarla:

kubectl

Para obtener información detallada sobre la implementación, ejecuta el siguiente comando:

kubectl describe deployment [DEPLOYMENT_NAME]

en el que [DEPLOYMENT_NAME] es el nombre de la implementación.

Para realizar una lista de los pods creados por la implementación, ejecuta el siguiente comando:

kubectl get pods -l [KEY]=[VALUE]

En este comando, la marca -l indica a kubectl que obtenga todos los pods con una etiqueta de clave-valor. Por ejemplo, si etiquetaras la implementación app: my-app, ejecutarías kubectl get pods -l app=my-app para ver los pods con esa etiqueta.

Para obtener información sobre un pod específico, usa este comando:

kubectl describe pod [POD_NAME]

Para ver el manifiesto de una implementación, ejecuta el siguiente comando:

kubectl get deployments [DEPLOYMENT_NAME] -o yaml

Este comando muestra la configuración activa de la implementación en formato YAML.

Console

Para inspeccionar una implementación, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. Para obtener más información sobre una carga de trabajo, selecciona la carga de trabajo deseada en el menú.

En el menú Cargas de trabajo, se ofrecen varias opciones:

  • Para ver la configuración activa de la implementación, haz clic en YAML.
  • Para ver todos los eventos relacionados con la implementación, haz clic en Eventos.
  • Para ver el historial de revisión de la implementación, haz clic en Historial de revisión.

Actualiza la implementación

Puedes implementar actualizaciones en la especificación de pods de una implementación, como su imagen, solicitud o uso de recursos, o su configuración.

Puedes actualizar una implementación mediante los siguientes métodos:

  • Puedes usar el menú Actualización progresiva y el editor de YAML del menú Cargas de trabajo de GCP Console.
  • Puedes realizar cambios en un archivo de manifiesto y aplicarlos con kubectl apply.
  • Puedes actualizar los campos image, resources o selector de la especificación de pod mediante kubectl set.
  • Puedes actualizar una implementación directamente desde tu shell o el editor que prefieras con kubectl edit.

kubectl apply

Puedes actualizar la implementación mediante la aplicación de un archivo de manifiesto nuevo o actualizado. Esto es útil para realizarle varios cambios a tu implementación, como escalarla o especificar una versión nueva de tu aplicación.

Para actualizar una implementación, ejecuta el siguiente comando:

kubectl apply -f [DEPLOYMENT_FILE]

En el que [DEPLOYMENT_FILE] es el archivo de manifiesto actualizado.

El comando kubectl apply aplica un archivo de manifiesto a un recurso. Si el recurso especificado no existe, el comando lo crea.

kubectl set

Puedes usar kubectl set para cambiar los campos de imagen, recursos (solicitudes o límites) o selector de una implementación.

Para cambiar la imagen de una implementación, ejecuta el siguiente comando:

kubectl set image deployment [DEPLOYMENT_NAME] [IMAGE] [IMAGE]:[TAG]

Por ejemplo, para actualizar una implementación desde la versión 1.7.9 a 1.9.1 de nginx, ejecuta el siguiente comando:

kubectl set image deployment nginx nginx=nginx:1.9.1

Console

El menú Actualización progresiva está disponible en el menú Cargas de trabajo.

Para acceder al menú Actualización progresiva de la implementación, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo deseada en el menú.

  3. Haz clic en Acciones y, luego, en Actualización progresiva.

Puedes realizar los siguientes cambios en la estrategia de actualización de la implementación:

  • Cantidad mínima de segundos de preparación: especifica la cantidad mínima de segundos en los que un pod recién creado debe estar listo para que se considere disponible.
  • Aumento máximo: campo opcional que especifica la cantidad máxima de pods que pueden crearse sobre el número deseado de pods. El valor puede ser un número absoluto o un porcentaje.
  • Máximo no disponible: campo opcional que especifica la cantidad máxima de pods que pueden no estar disponibles durante el proceso de actualización. El valor puede ser un número absoluto o un porcentaje.

    Para editar un contenedor existente, sigue estos pasos:

    1. En el menú Actualización progresiva, selecciona el contenedor para expandir su menú.
    2. Para cambiar el nombre del contenedor, edita el campo Nombre del contenedor.
    3. Para cambiar la imagen o versión del contenedor, edita el campo Nombre de imagen.
    4. Haz clic en Listo para guardar los cambios.
    5. Para borrar el contenedor, haz clic en el Ícono de la papelera.

    Para agregar un contenedor nuevo, sigue estos pasos:

    1. En el menú Actualización progresiva, haz clic en Agregar contenedor.
    2. Completa el campo Nombre de la imagen con la imagen y la versión, con el siguiente formato: [IMAGE_NAME]:[IMAGE_VERSION]. Por ejemplo, nginx:1.7.9.
    3. De forma opcional, rellena el campo Nombre del contenedor con un nombre para el contenedor.
    4. Haz clic en Listo.
  • Haz clic en Actualizar.

Para editar la configuración activa de una implementación, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo que desees.

  3. Haz clic en Editar.

  4. Usa el editor para realizar los cambios que desees en el objeto.

  5. Haz clic en Guardar.

Revierte una actualización

Puedes revertir una actualización con kubectl rollout undo.

Puedes revertir una actualización en progreso o completada a su revisión anterior con este comando:

kubectl rollout undo deployment my-deployment

También puedes revertir a una revisión específica si usas este otro comando:

kubectl rollout undo deployment my-deployment --to-revision=3

Escala una implementación

Puedes escalar de forma manual una implementación mediante GCP Console o kubectl scale.

Puedes obtener más información sobre cómo realizar el ajuste de escala automático de las implementaciones.

kubectl

kubectl scale puede usarse en cualquier momento para escalar la implementación.

Para escalar una implementación de forma manual, ejecuta el siguiente comando:

kubectl scale deployment [DEPLOYMENT_NAME] --replicas [NUMBER_OF_REPLICAS]

en el que [NUMBER_OF_REPLICAS] es la cantidad deseada de pods replicados.

Console

Para escalar una implementación, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. Selecciona la carga de trabajo deseada del menú.

  3. Haz clic en Acciones, y luego en Escalar.

  4. En el campo Réplicas, ingresa la cantidad de réplicas deseadas.

  5. Haz clic en Escalar.

Borra una implementación

Puedes borrar una implementación con GCP Console o kubectl delete.

kubectl

Para borrar una implementación, ejecuta el siguiente comando:

kubectl delete deployment [DEPLOYMENT_NAME]

Console

Para borrar una implementación, sigue estos pasos:

  1. Visita el menú Cargas de trabajo de Google Kubernetes Engine en GCP Console.

    Visitar el menú Cargas de trabajo

  2. En el menú, selecciona la carga de trabajo deseada.

  3. Haz clic en Borrar.

  4. Haz clic en Borrar en el menú de diálogo de confirmación.

Qué sigue

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Documentación de Kubernetes Engine