Administrar aplicaciones con la entrega de aplicaciones

En esta página, se explica cómo configurar una implementación de NGINX con Application Delivery. La implementación se ejecuta en dos entornos: staging y prod. El entorno prod usa una configuración regular, mientras que staging usa una ligeramente modificada.

Requisitos

Para completar este instructivo, necesitarás lo siguiente:

La versión 2.19.2 o una posterior de Git instalada de manera local
Una cuenta de GitHub o GitLab con permisos para crear un repositorio privado. Application Delivery solo admite repositorios de GitHub y GitLab
Un clúster con GKE 1.15 o superior
Un usuario con privilegios de clusterAdmin
Kustomize instalado de forma local. Puedes seguir la guía de instalación.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Asegúrate de que habilitaste la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Asegúrate de que instalaste el SDK de Cloud.

Establece la configuración de gcloud predeterminada mediante uno de los siguientes métodos:

Usa gcloud init si deseas ver una explicación sobre cómo configurar parámetros predeterminados.
Usa gcloud config para establecer el ID, la zona y la región del proyecto de manera individual.

Usa gcloud init

Si recibes el error One of [--zone, --region] must be supplied: Please specify location, completa esta sección.

Ejecuta gcloud init y sigue las instrucciones:
```
gcloud init
```
Si usas SSH en un servidor remoto, usa la marca --console-only para evitar que el comando abra un navegador:
```
gcloud init --console-only
```
Sigue las instrucciones a fin de autorizar a gcloud para que use tu cuenta de Google Cloud.
Crea una configuración nueva o selecciona una existente.
Elige un proyecto de Google Cloud.
Elige una zona predeterminada de Compute Engine.

Nota: Puedes anular esta configuración predeterminada en los comandos de gcloud mediante las marcas --project, --zone y --region.

Usa gcloud config

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

Nota: Puedes anular esta configuración predeterminada en los comandos de gcloud mediante las marcas --project, --zone y --region.

Agrega llaves SSH a tu cuenta de GitHub o GitLab.
Prueba tus llaves con ssh:
GitHub
```
ssh -T git@github.com
```
GitLab
```
ssh -T git@gitlab.com
```
Es posible que se te solicite que confirmes los detalles de conexión o tu frase de contraseña de la clave. Si la conexión se realiza correctamente, se imprimirá un mensaje en la terminal.

Configurar Application Delivery

Para usar la entrega de aplicaciones, debes hacer lo siguiente:

Crea un clúster nuevo con él habilitado o habilítalo en un clúster de GKE existente que ejecute la versión 1.15 o superior.
Instala appctl, la herramienta de línea de comandos de entrega de aplicaciones.

Crea un clúster nuevo con Application Delivery

Puedes crear un clúster nuevo con Application Delivery habilitada mediante gcloud o Cloud Console.

gcloud

Elige una versión de clúster 1.15.x o superior.

gcloud beta container clusters create cluster-name \
    --cluster-version cluster-version --addons ApplicationManager

Console

Ve al menú de Google Kubernetes Engine en Cloud Console.

Ir al menú Google Kubernetes Engine
Haz clic en Crear.
Especifica un Nombre para tu clúster.
Elige una versión principal de 1.15.x o superior.
Configura tu clúster como desees.
En el panel de navegación, en Clúster, haz clic en Funciones.
Selecciona la casilla de verificación Habilitar administrador de aplicaciones.
Haga clic en Crear.

Habilita Application Manager en un clúster existente

Puedes habilitar Application Delivery en un clúster existente con gcloud o Cloud Console.

gcloud

gcloud beta container clusters update cluster-name \
    --update-addons ApplicationManager=ENABLED

Console

Ve al menú de Google Kubernetes Engine en Cloud Console.

Ir al menú Google Kubernetes Engine
En la lista de clústeres, haz clic en el nombre del clúster que deseas modificar.
En Funciones, junto al campo Administrador de aplicaciones, haz clic en Editar administrador de aplicaciones.
Selecciona la casilla de verificación Habilitar administrador de aplicaciones.
Haz clic en Guardar cambios.

Confirma la instalación

Para comprobar el estado de instalación de Application Delivery, realiza lo siguiente:

Verifica el estado de la implementación:

kubectl get deployment application-controller-manager -n application-system

El resultado es similar al siguiente:

NAME                             READY   UP-TO-DATE   AVAILABLE   AGE
application-controller-manager   2/2     2            2           1h

Debería haber dos pods disponibles en este Deployment application-controller-manager.

Comprueba el estado del StatefulSet:
```
kubectl get statefulset kalm-controller-manager -n kalm-system
```
El resultado es similar al siguiente:
```
NAME                      READY   AGE
kalm-controller-manager   1/1     1h
```
Debería haber un pod listo en este StatefulSet kalm-controller-manager.

Instala appctl

Instala pkg, que incluye la herramienta de línea de comandos de Application Delivery appctl, con gcloud.

gcloud components install pkg

Después de habilitar Application Delivery en un clúster y de instalar pkg, estás listo para implementar tu primera aplicación.

Implementa una aplicación

Para implementar una aplicación, deberás realizar las siguientes tareas:

Crea repositorios de Git nuevos o inicializa repositorios existentes.
Crear una configuración básica
Crear uno o más entornos para la implementación.
También tienes la opción de aplicar superposiciones de configuración a tus entornos en el repositorio de tu aplicación
Crear una versión candidata en forma de solicitud de extracción o combinación
Implementa tu versión.

Crear repositorios nuevos

Crea repositorios para la entrega de aplicaciones en GitHub o GitLab con appctl.

Cambia al directorio en el que deseas crear el directorio de tu aplicación.
Crea tus repositorios de Application Delivery con appctl.
GitHub
```
appctl init application-name \
  --app-config-repo=github.com/user-name/application-name
```
Por ejemplo, si tu nombre de usuario de GitHub es octocat y quieres crear una aplicación llamada myapp, ejecuta lo siguiente:
```
appctl init myapp --app-config-repo=github.com/octocat/myapp
```
GitLab
```
appctl init application-name \
  --app-config-repo=gitlab.com/user-name/application-name
```
Por ejemplo, si tu nombre de usuario de GitLab es alice y quieres crear una aplicación llamada myapp, ejecuta lo siguiente:
```
appctl init myapp --app-config-repo=gitlab.com/alice/myapp
```
appctl te solicita que confirmes tus repositorios privados nuevos.

Nota: Git podría solicitarte información de acceso adicional.

appctl crea dos repositorios de Git privados remotos:

El repositorio de la aplicación github.com/user-name/application-name. Este repositorio se clona en el directorio actual.
El repositorio de implementación github.com/user-name/application-name-deployment. El repositorio de implementación local se almacena en ./application-name/.deployment.

Para obtener más información sobre el contenido y la estructura de estos repositorios, consulta la guía conceptual de Application Delivery.

Inicializa repositorios existentes

Si tienes repositorios existentes, puedes inicializar los repositorios para la entrega de aplicaciones en GitHub o GitLab con appctl.

Cambia al directorio donde deseas crear el directorio de tu aplicación.
Ejecuta el comando appctl init, que crea un directorio llamado application-name y clona tu repositorio allí.

El comando appctl init inicializa una capa base de Kustomize en los archivos de configuración almacenados en el directorio ./config del repositorio. Puedes especificar una ruta de configuración diferente con la marca --config-path.

De forma predeterminada, appctl init usa github.com/user-name/application-name-deployment como la URL del repositorio de implementación. Puedes usar la marca --deployment-repo para especificar una URL diferente. Si el repositorio de implementación no existe, el comando appctl creará uno.

Nota: Si ya existe un directorio application-name en la ruta local, appctl requiere que el directorio application-name se inicialice con Git y tenga una referencia remota. que coincida con el repositorio app-config-repo. Además, si el directorio application-name tiene un subdirectorio .deployment, el directorio .deployment se inicializará con Git y tendrá una referencia remota que coincida con el repositorio de implementación deployment-repo. Puedes usar la marca --deployment-repo para anular el valor predeterminado.
GitHub
```
appctl init application-name \
    --app-config-repo=github.com/user-name/application-name \
    [--config-path=config-path]
```
Por ejemplo, si el repositorio de configuración de la aplicación existente es https://github.com/octocat/myapp y esperas que el repositorio de implementación sea https://github.com/octocat/myapp-deploy, ejecuta el siguiente comando:
```
appctl init myapp --app-config-repo=github.com/octocat/myapp
```
GitLab
```
appctl init application-name \
  --app-config-repo=gitlab.com/user-name/application-name \
  [--config-path=config-path]
```
Por ejemplo, si el repositorio de configuración de la aplicación existente es gitlab.com/alice/myapp, ejecuta el siguiente comando:
```
appctl init myapp --app-config-repo=gitlab.com/alice/myapp
```

Crea una configuración básica

Cambia tu directorio de trabajo a tu repositorio de aplicaciones. Por ejemplo, si usaste el nombre de la aplicación myapp, ejecuta el siguiente comando:
```
cd myapp
```

Crea la configuración para tu carga de trabajo de Kubernetes. Puede ser cualquier implementación de Kubernetes válida.

La siguiente configuración define una aplicación llamada nginx, que implementa 3 réplicas del contenedor nginx. Copia la configuración en el archivo config/base/myapp.yaml. Si desea habilitar un LoadBalancer, quita el comentario de la línea type: LoadBalancer.

#myapp/config/base/myapp.yaml

apiVersion: v1
kind: Service
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  # if your cluster supports it, uncomment the following to automatically create
  # an external load-balanced IP for the frontend service.
  # type: LoadBalancer
  ports:
    - port: 80
  selector:
    app: nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.7.9
        ports:
        - containerPort: 80

Configura Application Delivery para aplicar esta configuración a la base. Pega lo siguiente en config/base/kustomization.yaml.
```
#config/base/kustomization.yaml

resources:
  - myapp.yaml
```

Prueba y envía tu configuración

En el directorio del repositorio de la aplicación, prueba tu configuración con kustomize build:
```
kustomize build config/base/
```
Nota: appctl usa un Kustomize integrado para evitar los conflictos entre versiones. Puede ser distinto a la versión de Kustomize local o al Kustomize instalado a través de gcloud components install pkg. Ejecuta appctl version a fin de ver la versión integrada de Kustomize. Ejecuta kustomize version para ver tu versión local de Kustomize.

Si la configuración es válida, kustomize imprime el YAML que se implementará en tu clúster cuando se aplique.
Una vez que hayas validado tu YAML, crea y envía una confirmación en el repositorio de tu aplicación.
```
git add .
git commit -m "Creating application-name"
git push origin master
```

Agrega un entorno de actualización

Application Delivery implementa tu aplicación en entornos. Puedes agregar entornos para tus actualizaciones con appctl.

Cambia al directorio raíz del repositorio de la aplicación (por ejemplo, cd myapp).
Crea tu entorno con appctl
```
appctl env add environment-name --cluster=cluster-name
```
appctl crea una confirmación de Git que contiene una configuración de Kustomize respaldada.

Puedes especificar el nombre del espacio de nombres para un entorno de actualización de esta aplicación con --namespace. Si no lo haces, el nombre del espacio de nombres predeterminado es application-name-environment-name. Por ejemplo, para agregar los entornos staging y prod al clúster application-cluster con el nombre del espacio de nombres predeterminado, ejecuta el siguiente comando:
```
appctl env add staging --cluster=application-cluster
appctl env add prod --cluster=application-cluster
```
Para agregar el entorno test en el espacio de nombres test al clúster application-cluster, ejecuta el siguiente comando:
```
appctl env add test --cluster=application-cluster --namespace=test
```
Cuando agregas un entorno, debes evaluar si se necesitan solicitudes de extracción y revisiones de código en el repositorio de implementación para este entorno. De forma predeterminada, se crean solicitudes de extracción. Si el entorno no es esencial para la producción y no es necesario revisar el código. Puedes omitir la creación de solicitudes de extracción con --review-required=false. Por ejemplo, para agregar el entorno test, que no necesita crear solicitudes de extracción.
```
appctl env add test --cluster=application-cluster --review-required=false
```
Nota: appctl puede solicitarte un token de acceso para tu repositorio de Git.
De manera opcional, puedes ver los cambios que realizó Application Delivery en tu repositorio de Git con git log.
```
git log -p *
```
Envía la configuración al repositorio de tu aplicación.
```
git push origin master
```

Opcional: Comprobar el repositorio de implementación

Abre la página de GitHub o GitLab para tu repositorio de implementación. Por ejemplo, si tu nombre de usuario de GitHub es octocat y creaste una aplicación llamada myapp, la URL es https://github.com/octocat/myapp-deployment. Desde esta página, puedes ver las ramas que se crearon para cada entorno.

Implementa un entorno

Para implementar un entorno con la entrega de aplicaciones, realiza lo siguiente:

Crea una versión con git tag y envía esa etiqueta.
```
git tag version
git push origin version
```
Nota: Te recomendamos usar Control de versiones semánticas para tus números de versión. Esto te permite ordenar las versiones fácilmente en las páginas de GitHub o GitLab.

Por ejemplo, para enviar la versión v0.1.0, ejecuta los siguientes comandos:
```
git tag v0.1.0
git push origin  v0.1.0
```
Usa appctl prepare a fin de nominar la versión etiquetada y generar una solicitud de extracción en el repositorio de implementación para revisión.

Nota: appctl prepare restablece tu kubeconfig, incluidos el contexto predeterminado y el espacio de nombres. Si cambiaste el contexto predeterminado, deberás volver a aplicar este cambio después de usar appctl.
```
appctl prepare environment-name
```
Por ejemplo, para usar el entorno staging, ejecuta el siguiente comando:
```
appctl prepare staging --validate=true
```
Activa la función de validación de kpt gcr.io/kustomize-functions/example-validator para validar el cambio que se envía al repositorio de implementación.

gcloud components install pkg instala kpt. Esta función de validación ejecuta kubeval de forma interna, lo que valida los archivos de configuración de Kubernetes mediante esquemas de la especificación de OpenAPI de Kubernetes.

De manera predeterminada, la marca "--validate" está inhabilitada.

Nota: Si se desinstala kpt, habilitar la marca “--validate” genera un error.

Si appctl completó la confirmación en el repositorio de implementación, imprime una URL en una solicitud de extracción, como la que se muestra a continuación:
```
Created a "Pull Request": "https://github.com/octocat/myapp-deployment/pull/[Pull_Request_ID]"
```
Nota: Si el entorno se crea con --review-required=false, appctl prepare omite la creación de una solicitud de extracción y envía el cambio al repositorio de implementación. No verás el vínculo de la solicitud de extracción.
Usa GitHub o GitLab para revisar y aprobar la solicitud de extracción.

Precaución: Cuando combines solicitudes de extracción en GitHub o GitLab, usa una confirmación de combinación. Application Delivery no puede identificar las confirmaciones "aplastar y combinar" o "modificar y combinar".
Una vez que se apruebe la solicitud de extracción, usa appctl apply para completar la implementación.
```
appctl apply environment-name
```
Por ejemplo, para implementar cambios en el entorno staging, ejecuta lo siguiente:
```
appctl apply staging
```
Confirma que tu aplicación se está ejecutando con kubectl o desde Cloud Console.
kubectl
Usa kubectl describe para ver el estado de tu aplicación.
```
 kubectl get releasetracks.app.gke.io application-name -n \
     [application-name-environment-name or customized_namespace`] -w
```
Reemplaza lo siguiente:
- application-name: Es el nombre del repositorio de tu aplicación.
- environment-name: Es el nombre de tu entorno.
- customized_namespace: Es el nombre del espacio de nombres que se especificó antes en env add.
Por ejemplo, para verificar el estado del entorno staging de la aplicación llamada myapp, ejecuta el siguiente comando:
```
kubectl get releasetracks.app.gke.io myapp -n myapp-staging
```
Para verificar el estado del entorno test que env add --namespace test agregó antes, ejecuta el siguiente comando:
```
kubectl get releasetracks.app.gke.io myapp -n test
```
Console
Para ver el estado y la información de la versión de las aplicaciones implementadas con Application Delivery, consulta la página de aplicaciones de GKE en Cloud Console.

Promueve una actualización

Para promover una versión candidata de un entorno a otro, ejecuta el siguiente comando:
```
appctl prepare target-environment-name \
    --from-env source-environment-name
```
Reemplaza lo siguiente:
- target-environment-name: Es el nombre del entorno en el que deseas implementar la versión candidata para el lanzamiento.
- source-environment-name: Es el nombre del entorno actual.
Por ejemplo, para promover staging a prod ejecuta lo siguiente:
```
appctl prepare prod --from-env staging
```
Usa GitHub o GitLab para revisar y aprobar la solicitud de extracción.
Para implementar la versión candidata en el entorno de destino, ejecuta el siguiente comando:
```
appctl apply target-environment-name
```
Por ejemplo, para implementar en el entorno prod, ejecuta el siguiente comando:
```
appctl apply prod
```

Visualiza entornos en Cloud Console

Una vez que se implementa la aplicación de un entorno, puedes verla en la página Aplicaciones de GKE. Esta página contiene una lista de aplicaciones con sus entornos marcados entre paréntesis. A continuación, se muestra una captura de pantalla de una aplicación myapp con dos entornos staging y prod. El espacio de nombres, el clúster y la versión de cada entorno también se muestran en esta página.

Una captura de pantalla de la página de la aplicación.

Para ver los detalles de la aplicación, como la etiqueta git, los componentes y la lista de entornos, haz clic en el nombre de la aplicación. La siguiente captura de pantalla muestra los detalles de myapp.

Una captura de pantalla de la página de detalles de la aplicación.

Cambia la configuración de un entorno

En esta sección, se supone que tienes un entorno staging configurado como en los pasos anteriores. Es posible que debas adaptar estas instrucciones para tu situación.

En esta sección, se cambian los parámetros del entorno staging mediante una superposición kustomize. Después de realizar el cambio, envía y etiqueta tus cambios en Git. Application Delivery actualizará tu clúster.

Crea un archivo llamado config/envs/staging/patch-replicas.yaml y copia el siguiente texto en él. Esto actualiza la configuración en el entorno staging para ejecutar una réplica en lugar de tres.
```
#config/envs/staging/patch-replicas.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 1
```
Nota: Los valores apiVersion, kind y metadata.name son obligatorios.
Edita el archivo config/envs/staging/kustomization.yaml y agrega patch-replicas.yaml a una colección nueva llamada patchesStrategicMerge.
```
#config/envs/staging/kustomization.yaml
namespace: myapp-staging
bases:
   - ../../base
patchesStrategicMerge:
   - patch-replicas.yaml
```
También puedes agregar anotaciones específicas del entorno en esta superposición. En el siguiente ejemplo, se agrega una anotación llamada oncall-team para incorporar todos los recursos de este entorno. Para obtener más información, consulta Campos del archivo de Kustomize.
```
#config/envs/staging/kustomization.yaml

#Don't change the namespace field
namespace: myapp-staging
bases:
   - ../../base
patchesStrategicMerge:
   - patch-replicas.yaml
commonAnnotations:
  oncall-team: staging-oncall@foo.bar
```
Prueba tu configuración con kustomize build:
```
kustomize build config/envs/staging/
```
Agrega y confirma tus cambios.
```
git add .
git commit -m "commit-message"
git push origin master
```
Reemplaza commit-message con un mensaje que describa tus cambios.

Crea una versión con git tag y envíala.

git tag version
git push origin  version

Usa appctl prepare a fin de generar una solicitud de extracción en el repositorio de implementación para revisión.
```
appctl prepare environment-name
```
Sigue el vínculo para crear una solicitud de extracción de GitHub o GitLab.
Revisa el contenido de tu solicitud de extracción. Application Delivery realiza un cambio de una línea que establece el valor de replicas en 1.
Aprueba la solicitud de extracción con GitHub o GitLab.
Usa appctl apply para aplicar los cambios.
```
appctl apply staging
```

Revierte los cambios de configuración

Para revertir a una versión anterior, ejecuta el siguiente comando:

appctl apply target-environment-name --from-tag git-tag

Reemplaza lo siguiente:

target-environment-name: Es el nombre del entorno en el que deseas implementar la versión.
git-tag: Es el nombre de la etiqueta para la versión.

Usa appctl en secuencias de comandos

La herramienta appctl es interactiva y espera la entrada del usuario de forma predeterminada. Si desea ejecutar appctl en una secuencia de comandos, un contenedor o canalizaciones, establece la variable de entorno APPCTL_INTERACTIVE en false.

Por ejemplo, en el shell Bash, ejecuta el siguiente comando.

export APPCTL_INTERACTIVE=false

La información sobre comandos appctl específicos está disponible con appctl help command. Por ejemplo, para obtener ayuda con appctl prepare, ejecuta appctl help prepare.

Desinstala Application Manager

Para quitar la aplicación que se ejecuta en tu clúster, borra todos los espacios de nombres creados con entornos nuevos.

Para todos tus entornos y clústeres, repite los siguientes comandos:

Cambiar al clúster a un entorno determinado

kubectl config use-context ${CONTEXT_OF_ENV_CLUSTER}

Borrar el espacio de nombres en que se ejecuta tu aplicación para este entorno
```
 kubectl delete ns [application-name-environment-name or customized_namespace`]
```
Reemplaza lo siguiente:
- application-name: Es el nombre del repositorio de tu aplicación.
- environment-name: Es el nombre de tu entorno.
- customized_namespace: Es el nombre del espacio de nombres que se especificó antes en env add.
En GitHub o GitLab, borra los dos repositorios de Git creados por appctl.
Borra el directorio de tu aplicación local:
```
rm -rf myapp/
```
Puedes inhabilitar Application Delivery en tu clúster desde gcloud o Cloud Console:
gcloud
```
gcloud beta container clusters update cluster-name \
--update-addons ApplicationManager=DISABLED
```
Console
1. Ve al menú de Google Kubernetes Engine en Cloud Console.
  
  Ir al menú Google Kubernetes Engine
2. En la lista de clústeres, haz clic en el nombre del clúster que deseas modificar.
3. En Funciones, junto al campo Administrador de aplicaciones, haz clic en Editar administrador de aplicaciones.
4. Desactiva la casilla de verificación Habilitar el administrador de aplicaciones.
5. Haz clic en Guardar cambios.

¿Qué sigue?

Obtén más información sobre Kustomize.