Instala Kf

En este documento, se describe cómo configurar un clúster de GKE y, luego, instalar Kf y sus dependencias.

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.

Requisitos del clúster de GKE

• 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.

Requisitos de Kf. La Matriz de dependencia enumera las versiones especificadas.

• Artifact Registry.

• Anthos Service Mesh.

• Config Connector.

• Tekton para que lo use Kf. Este no es un servicio orientado al usuario.

• Una Cuenta de servicio de Google dedicada.

Nota: En la sección Limpiar, verás 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. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

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

4. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

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

6. Habilita la API de Compute Engine.

   Habilita la API

Habilita la compatibilidad con Artifact Registry

1. Habilita la API de Artifact Registry.

   Habilita la API de Artifact Registry

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.

Prepara un nuevo clúster de GKE y servicios relacionados

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 conectarte más adelante, deberás volver a configurar las variables.

Linux y Mac

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} # Replace ZONE with REGION to switch
export NODE_COUNT=4
export MACHINE_TYPE=e2-standard-4
export NETWORK=default

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 # Replace ZONE with REGION to switch
Set-Variable -Name NODE_COUNT -Value 4
Set-Variable -Name MACHINE_TYPE -Value e2-standard-4
Set-Variable -Name NETWORK -Value default

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. Crea una nueva función de IAM personalizada.

   gcloud iam roles create serviceAccountUpdater \
   --project=${CLUSTER_PROJECT_ID} \
   --title "Service Account Updater" \
   --description "This role only updates members on a GSA" \
   --permissions iam.serviceAccounts.get,iam.serviceAccounts.getIamPolicy,iam.serviceAccounts.list,iam.serviceAccounts.setIamPolicy

3. 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 projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="projects/${CLUSTER_PROJECT_ID}/roles/serviceAccountUpdater"

4. 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"

5. 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 \
  --project=${CLUSTER_PROJECT_ID} \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${CLUSTER_PROJECT_ID}.svc.id.goog[kf/controller]" \
  "${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com"

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

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} \
     --project=${CLUSTER_PROJECT_ID} \
     --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} \
     --project=${CLUSTER_PROJECT_ID} \
     --location=${COMPUTE_REGION} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role='roles/artifactregistry.writer'

Instala dependencias de software en el clúster

Nota: La matriz de dependencia en la página Descargas de Kf tiene versiones fijadas para la versión de Kf determinada.

1. Instala Service Mesh.

   1. Abre la guía de actualización de Anthos Service Mesh.

   2. Asegúrate de que el menú desplegable de versiones esté configurado en la versión 1.9 de Anthos Service Mesh.

   3. Sigue la guía para instalar ASM.

2. Instala Config Connector.

   Nota: Se requiere Config Connector desde Kf v2.4.0 en adelante.
   Advertencia: No uses el método del complemento de GKE para instalar Config Connector, ya que no es compatible con Kf. Usa estos pasos de instalación personalizados.

   1. Descarga el archivo tar de Config Connector más reciente.

      Nota: Conserva una copia del paquete de instalación, ya que lo necesitarás para desinstalar Config Connector.

   2. Extrae el archivo tar.

      tar zxvf release-bundle.tar.gz
      

   3. Instala el operador de Config Connector en tu clúster.

      kubectl apply -f operator-system/configconnector-operator.yaml
      

   4. Configura el operador de Config Connector:

      1. Copia el siguiente YAML en un archivo llamado configconnector.yaml:

         Advertencia:KF_SERVICE_ACCOUNT_NAME Reemplaza la variable ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com del archivo YAML que se muestra a continuación por la cuenta de servicio completa que se resolvió en

         # configconnector.yaml
         apiVersion: core.cnrm.cloud.google.com/v1beta1
         kind: ConfigConnector
         metadata:
           # the name is restricted to ensure that there is only one
           # ConfigConnector resource installed in your cluster
           name: configconnector.core.cnrm.cloud.google.com
         spec:
           mode: cluster
           googleServiceAccount: "KF_SERVICE_ACCOUNT_NAME" # Replace with the full service account resolved from ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
         

      2. Aplica la configuración al clúster.

         kubectl apply -f configconnector.yaml

   5. Verifica que Config Connector esté completamente instalado antes de continuar.

      • Config Connector ejecuta todos sus componentes en un espacio de nombres llamado cnrm-system. Ejecuta el siguiente comando para verificar que los Pods estén listos:

        Nota: El Pod controlador puede tardar varios minutos en iniciarse, por lo que este comando podría no funcionar de inmediato.

        kubectl wait -n cnrm-system --for=condition=Ready pod --all

      • Si Config Connector está instalado de forma correcta, espera un resultado similar al siguiente:

        pod/cnrm-controller-manager-0 condition met
        pod/cnrm-deletiondefender-0 condition met
        pod/cnrm-resource-stats-recorder-86858dcdc5-6lqzb condition met
        pod/cnrm-webhook-manager-58c799b8fb-kcznq condition met
        pod/cnrm-webhook-manager-58c799b8fb-n2zpx condition met

   6. Configura Workload Identity.

      kubectl annotate serviceaccount \
      --namespace cnrm-system \
      --overwrite \
      cnrm-controller-manager \
      iam.gke.io/gcp-service-account=${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com

3. Instala Tekton:

   kubectl apply -f "https://storage.googleapis.com/tekton-releases/pipeline/previous/v0.23.0/release.yaml"

Instala Kf

Nota: Asegúrate de que tu clúster cumpla con los requisitos que se encuentran en Crea y prepara un clúster de GKE para Kf.

1. Instala la CLI de Kf:

   Linux

   Con este comando, se instala la CLI de 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/v2.4.1/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Mac

   Con este comando, se instala kf para todos los usuarios del sistema.

   gsutil cp gs://kf-releases/v2.4.1/kf-darwin /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf
   

   Cloud Shell

   Este comando 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/v2.4.1/kf-linux ~/bin/kf
   chmod a+x ~/bin/kf
   echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
   source ~/.bashrc
   

   Windows

   Con este comando, se descarga 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/v2.4.1/kf-windows.exe kf.exe
   

2. Instala el operador:

   kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.4.1/operator.yaml"

3. Configura el operador para Kf:

   kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.4.1/kfsystem.yaml"

4. Configura secretos y valores predeterminados:

   export CONTAINER_REGISTRY=${COMPUTE_REGION}-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}
   
   kubectl patch \
   kfsystem kfsystem \
   --type='json' \
   -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': true, 'config': {'spaceContainerRegistry': '${CONTAINER_REGISTRY}', 'secrets':{'workloadidentity':{'googleserviceaccount':'${CLUSTER_NAME}-sa', 'googleprojectid':'${CLUSTER_PROJECT_ID}'}}}}}]"
   

Valida la instalación

  kf doctor --retries=20

Nota: Este comando inspeccionará el clúster para garantizar que Kf y sus dependencias estén instalados y en funcionamiento. Se ejecutará hasta 20 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.

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 la cuenta de servicio de Google:

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

2. 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"

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

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

4. Borra el clúster de GKE:

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