Guía de inicio rápido de Kf

En esta guía de inicio rápido, configurarás un clúster de GKE, instalarás Kf y sus dependencias, y, luego, implementarás una aplicación de muestra de Cloud Foundry.

Antes de comenzar

Descripción general

Nota: En este momento, los clústeres de GKE con Autopilot no pueden ejecutar Kf. Usa un clúster de GKE estándar. Para obtener más información sobre estos modos y sobre Autopilot, consulta la descripción general de Autopilot.

• El clúster de GKE debe cumplir con los siguientes requisitos:

  • Se recomienda que el clúster esté dedicado a Kf (opcional). Te recomendamos que solo instales Kf y sus dependencias para garantizar que se mantenga la matriz de compatibilidad.

  • Debe tener al menos cuatro nodos. Si necesitas agregar nodos, consulta Cambia el tamaño de un clúster.

  • El tipo de máquina mínimo debe tener al menos cuatro CPU virtuales, como e2-standard-4. Si el tipo de máquina del clúster no tiene al menos cuatro CPU virtuales, cámbialo como se describe en Migra cargas de trabajo a diferentes tipos de máquina.

  • Aunque es una acción opcional, se recomienda inscribir el clúster en un canal de versiones. Sigue las instrucciones en Inscribe un clúster existente en un canal de versiones si tienes una versión estática de GKE.

  • Workload Identity debe estar habilitado.

  • Artifact Registry debe estar habilitado.

  • Anthos Service Mesh (ASM).

  • Tekton debe estar instalado. Consulta la Matriz de dependencia para la versión.

  • Se debe contar con una cuenta de servicio de Google con la siguiente política de IAM (consulta el vínculo de instrucciones de creación a continuación):

    • roles/iam.serviceAccountAdmin
    • serviceAccount:${CLUSTER_PROJECT}.svc.id.goog[kf/controller] (para el miembro serviceAccount:${CLUSTER_PROJECT}.svc.id.goog[kf/controller])

En la sección Limpiar, verás las instrucciones para borrar el clúster.

Habilita la compatibilidad con Compute Engine

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

6. Habilita la API de Compute Engine.

   Habilitación de la API

Habilita y configura GKE

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

• Habilita la API de Google Kubernetes Engine.
Habilitar la API de Google Kubernetes Engine
• Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
  Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Crea y prepara un clúster de GKE nuevo

Configura variables de entorno

Nota: Exporta estas variables de entorno en tu terminal o Cloud Shell para que funcionen los comandos posteriores. Si te desconectas del entorno de shell y vuelves a conectarse más adelante, deberás configurar las variables nuevamente.

Nota: Antes de configurar las variables de entorno, asegúrate de consultar la matriz de dependencia en la página Descargas de Kf para la versión de Kf determinada.

Linux

export PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_NAME=kf-cluster
export COMPUTE_ZONE=us-central1-a
export COMPUTE_REGION=us-central1
export CLUSTER_LOCATION=${COMPUTE_ZONE}
export NODE_COUNT=4
export MACHINE_TYPE=e2-standard-4
export NETWORK=default
export KF_VERSION=v2.1.0
export TEKTON_VERSION=v0.19.0

Windows Powershell

Set-Variable -Name PROJECT_ID -Value YOUR_PROJECT_ID
Set-Variable -Name CLUSTER_PROJECT_ID -Value YOUR_PROJECT_ID
Set-Variable -Name CLUSTER_NAME -Value kf-cluster
Set-Variable -Name COMPUTE_ZONE -Value us-central1-a
Set-Variable -Name COMPUTE_REGION -Value us-central1
Set-Variable -Name CLUSTER_LOCATION -Value $COMPUTE_ZONE
Set-Variable -Name NODE_COUNT -Value 4
Set-Variable -Name MACHINE_TYPE -Value e2-standard-4
Set-Variable -Name NETWORK -Value default
Set-Variable -Name KF_VERSION -Value v2.1.0
Set-Variable -Name TEKTON_VERSION -Value v0.19.0

Configuración de la cuenta de servicio

Crea una cuenta de servicio de GCP (GSA) que se asociará a una cuenta de servicio de Kubernetes mediante Workload Identity. Esto evita la necesidad de crear e insertar una clave de cuenta de servicio.

Nota: Lee y comprende las implicaciones de seguridad del uso de Workload Identity en el documento Descripción general de seguridad.

1. Crea la cuenta de servicio que usará Kf.

   gcloud iam service-accounts create ${CLUSTER_NAME}-sa \
     --project=${CLUSTER_PROJECT_ID} \
     --description="GSA for Kf ${CLUSTER_NAME}" \
     --display-name="${CLUSTER_NAME}"

2. Permite que la cuenta de servicio modifique su propia política. El controlador Kf lo usará para agregar espacios (de nombre) nuevos a la política, lo que permite volver a usar Workload Identity.

   gcloud iam service-accounts add-iam-policy-binding ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com \
     --project=${CLUSTER_PROJECT_ID} \
     --role="roles/iam.serviceAccountAdmin" \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com"

3. Otorga la función de métricas de supervisión para el acceso de escritura a Cloud Monitoring.

   gcloud projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter"

4. Otorga la función de registro para el acceso de escritura a Cloud Logging.

   gcloud projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter"

Crea un clúster de GKE

Nota: Para fines de demostración, en estas instrucciones, se usa un clúster zonal. Para las implementaciones de producción, se recomienda usar un clúster regional.

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${CLUSTER_PROJECT_ID} \
  --zone=${CLUSTER_LOCATION} \
  --num-nodes=${NODE_COUNT} \
  --machine-type=${MACHINE_TYPE} \
  --network=${NETWORK} \
  --addons=HttpLoadBalancing,HorizontalPodAutoscaling,NetworkPolicy \
  --enable-stackdriver-kubernetes \
  --enable-ip-alias \
  --enable-network-policy \
  --enable-autorepair \
  --enable-autoupgrade \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --release-channel=regular \
  --workload-pool="${CLUSTER_PROJECT_ID}.svc.id.goog" \
  --service-account="${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com"

Configura reglas de firewall

Kf requiere que se abran algunos puertos de firewall. El nodo principal debe ser capaz de comunicarse con los pods en los puertos 80, 443, 8080, 8443 y 6443.

Habilitar Workload Identity

Ahora que tienes una cuenta de servicio y un clúster de GKE, asocia el espacio de nombres de identidad del clúster con el clúster.

gcloud iam service-accounts add-iam-policy-binding \
  "${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
  --project=${CLUSTER_PROJECT_ID} \
  --role="roles/iam.workloadIdentityUser" \
  --member="serviceAccount:${CLUSTER_PROJECT_ID}.svc.id.goog[kf/controller]"

Orienta el clúster de GKE

Configura el acceso a la línea de comandos de kubectl mediante el siguiente comando:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --project=${CLUSTER_PROJECT_ID} \
    --zone=${CLUSTER_LOCATION}

Crea un repositorio de Artifact Registry

1. Crea un Artifact Registry para almacenar imágenes de contenedor.

   gcloud artifacts repositories create ${CLUSTER_NAME} \
     --repository-format=docker \
     --location=${COMPUTE_REGION}

2. Otorga permiso a la cuenta de servicio en el repositorio de Artifact Registry.

   gcloud artifacts repositories add-iam-policy-binding ${CLUSTER_NAME} \
     --location=${COMPUTE_REGION} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role='roles/artifactregistry.writer'

3. Configura tu autenticación local.

   gcloud auth configure-docker ${COMPUTE_REGION}-docker.pkg.dev

Instala dependencias de software en el clúster

Nota: Antes de instalar cualquier elemento, asegúrate de verificar la matriz de dependencia en la página Descargas de Kf para la versión de Kf determinada.

1. Instalar Service Mesh.

   Nota: Consulta la matriz de dependencia para conocer la versión correcta.

2. Instala Tekton:

   Nota: Consulta la matriz de dependencia para conocer la versión correcta.

   kubectl apply -f "https://github.com/tektoncd/pipeline/releases/download/${TEKTON_VERSION}/release.yaml"

Instala Kf

1. Consulta Crea y prepara un clúster de GKE para Kf a fin de crear un clúster preparado con el objetivo de ejecutar Kf.

2. Selecciona la versión de Kf que quieras y anótala. Consulta la página Descargas de Kf para conocer las versiones disponibles.

   Nota: Muchos de los comandos de esta guía dependen de estas variables de entorno. Si te desconectas del entorno de shell y vuelves a conectarte más adelante, deberás configurar las variables otra vez.

3. Instala CLI:

   Linux

   Esto instalará kf para todos los usuarios del sistema. Sigue las instrucciones de la pestaña de Cloud Shell para instalarlo tú mismo.

   gsutil cp gs://kf-releases/${KF_VERSION}/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Mac

   Esto instalará kf para todos los usuarios del sistema.

   gsutil cp gs://kf-releases/${KF_VERSION}/kf-darwin /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Cloud Shell

   Esto instalará kf en tu instancia de Cloud Shell si usas bash. Es posible que tengas que modificar las instrucciones para otros shells.

   mkdir -p ~/bin
   gsutil cp gs://kf-releases/${KF_VERSION}/kf-linux ~/bin/kf
   chmod a+x ~/bin/kf
   echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
   source ~/.bashrc
   

   Windows

   Esta acción descargará kf en el directorio actual. Agrégalo a la ruta si deseas llamar desde cualquier otro lugar que no sea el directorio actual.

   gsutil cp gs://kf-releases/${KF_VERSION}/kf-windows.exe kf.exe
   

4. Instala los componentes del servidor:

   Linux y Mac

   Esta acción descargará kf.yaml en el directorio actual.

   gsutil cp gs://kf-releases/${KF_VERSION}/kf.yaml /tmp/kf.yaml
   kubectl apply -f /tmp/kf.yaml
   

   Windows

   Esta acción descargará kf.yaml en el directorio actual.

   gsutil cp gs://kf-releases/${KF_VERSION}/kf.yaml kf.yaml
   kubectl apply -f kf.yaml
   

5. Configura secretos:

   export WI_ANNOTATION=iam.gke.io/gcp-service-account=${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
   
   kubectl annotate serviceaccount controller ${WI_ANNOTATION} \
   --namespace kf \
   --overwrite
   
   echo "{\"apiVersion\":\"v1\",\"kind\":\"ConfigMap\",\"metadata\":{\"name\":\"config-secrets\", \"namespace\":\"kf\"},\"data\":{\"wi.googleServiceAccount\":\"${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com\"}}" | kubectl apply -f -

6. Configura los valores predeterminados de Kf. Estos valores pueden modificarse más adelante. En el ejemplo siguiente, se usan plantillas de dominio con un proveedor de DNS comodín para proporcionar a cada espacio su propio nombre de dominio:

   export CONTAINER_REGISTRY=${COMPUTE_REGION}-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}
   export DOMAIN='$(SPACE_NAME).$(CLUSTER_INGRESS_IP).nip.io'
   
   kubectl patch configmaps config-defaults \
   -n=kf \
   -p="{\"data\":{\"spaceContainerRegistry\":\"${CONTAINER_REGISTRY}\",\"spaceClusterDomains\":\"- domain: ${DOMAIN}\"}}"

7. Valida la instalación:

   kf doctor --retries 10

   Nota: Este comando inspeccionará el clúster para garantizar que Kf y sus dependencias estén instalados y en funcionamiento. Se ejecutará hasta 10 veces para que el clúster de Kubernetes se concilie y debería generar una serie PASS de resultados. Si el estado de cualquier componente da como resultado FAIL después de los reintentos, consulta la página de Solución de problemas de Kf.

Envía una aplicación

Requisitos

Para completar esta sección, se requiere lo siguiente:

1. Kf debe estar instalado en un clúster de GKE compatible. Consulta Instala Kf para obtener instrucciones.
2. De debe contar con un .kubeconfig orientado al clúster de Kf. Si creaste el clúster según las instrucciones de este documento, esto ya estará hecho. Puedes generar la configuración de forma explícita con gcloud container clusters get-credentials ${CLUSTER_NAME} --zone ${CLUSTER_LOCATION}.
3. La CLI de kf debe estar instalada en tu ruta de acceso. Consulta Instala Kf para obtener instrucciones.
4. La CLI de git debe estar instalada en tu ruta de acceso.

Prepara el espacio

1. Crea un espacio nuevo:

   kf create-space test-space

2. Orienta el espacio:

   kf target -s test-space

Envía la app de prueba de Cloud Foundry

1. Clona el repositorio test-app:

   git clone https://github.com/cloudfoundry-samples/test-app go-test-app
   cd go-test-app

2. Envía la app:

   kf push test-app

3. Busca la URL de la aplicación:

   1. Usa el formato de salida para recuperar solo la ruta:

      kf app test-app --output 'jsonpath={.status.urls[0]}'

   2. O lo siguiente para un enfoque de CF más tradicional:

      kf apps

   Nota: La app estableció la propiedad de ruta aleatoria.

4. Abre la URL en tu navegador.

Limpia

Con estos pasos, deberías quitar todos los componentes creados en la sección Crear y preparar un clúster de GKE nuevo.

1. Borra el clúster de GKE:

   gcloud container clusters delete ${CLUSTER_NAME} --zone ${CLUSTER_LOCATION}

2. Borra la cuenta de servicio de Google:

   gcloud iam service-accounts delete ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com

3. Borra las vinculaciones de políticas de IAM:

   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/storage.admin"
   
   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/iam.serviceAccountAdmin"
   
   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter"

4. Borra el repositorio de imágenes del contenedor:

   gcloud artifacts repositories delete ${CLUSTER_NAME} \
     --location=${COMPUTE_REGION}