Versión 2.11 (versión más reciente)

Versiones disponibles

2.11 (versión más reciente)
2.10
2.9
2.7: EOL/no compatible
2.6: EOL/no compatible
2.8: EOL/No compatible
2.5: EOL/no compatible
2.4: EOL/no compatible
2.3: EOL/no compatible
2.2: EOL/No compatible
2.1: EOL/No compatible

Instala Kf en Google Cloud

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

Antes de comenzar

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

Revisa y comprende los permisos de acceso de los componentes en Kf en la página de dependencias y arquitectura de Kf.

La Matriz de dependencia enumera las versiones especificadas.

Artifact Registry
Cloud 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

Habilita la compatibilidad con Compute Engine

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

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

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Habilita la API de Compute Engine.
Habilita la API

Habilita la compatibilidad con Artifact Registry

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

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

WindowsPowerShell

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

Configura la cuenta de servicio

Crea una cuenta de servicio de Google Cloud 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.

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}"

Crea un nuevo rol 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

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"

Otorga el rol 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"

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

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${CLUSTER_PROJECT_ID} \
  --zone=${CLUSTER_LOCATION} \
  --num-nodes=${NODE_COUNT} \
  --machine-type=${MACHINE_TYPE} \
  --disk-size "122" \
  --network=${NETWORK} \
  --addons HorizontalPodAutoscaling,HttpLoadBalancing,GcePersistentDiskCsiDriver \
  --enable-dataplane-v2 \
  --enable-stackdriver-kubernetes \
  --enable-ip-alias \
  --enable-autorepair \
  --enable-autoupgrade \
  --scopes 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

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}

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 un clúster

Instala Cloud Service Mesh v1.17.4-asm.2+config1.

Nota: Cuando instales puertas de enlace que sigan el documento de ASM, selecciona “Etiqueta de revisión” en el paso 2, ya que esa es la forma en que Kf es compatible.
1. Sigue la guía de instalación de Cloud Service Mesh, que incluye los pasos para crear una puerta de enlace de entrada.
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 requerido del operador de Config Connector.
  
  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 del 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
```

Instala Tekton:

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

Instala Kf

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.11.21/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.11.21/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.11.21/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.11.21/kf-windows.exe kf.exe
```

Instala el operador:

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

Configura el operador para Kf:

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

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

Realiza una limpieza

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

Borra la cuenta de servicio de Google:

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

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/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"

Borra el repositorio de imágenes del contenedor:

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

Desinstala Kf:

kubectl patch kfsystem kfsystem \
  --type='json' \
  -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': false, }}]"

(Opcional) Borra el clúster de GKE:

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