Esta página se ha traducido con Cloud Translation API.

Ejecutar una tarea de Spark en Dataproc en Google Kubernetes Engine

Antes de empezar

Debes haber creado un clúster zonal o regional de Google Kubernetes Engine (GKE) estándar (no Autopilot) que tenga habilitada la función Identidad de carga de trabajo.
Consejo sobre el rendimiento: habilita la distribución de imágenes en streaming para que las cargas de trabajo se inicialicen más rápido.

Crear un clúster virtual de Dataproc en GKE

Se crea un clúster virtual de Dataproc en GKE como plataforma de implementación de los componentes de Dataproc. Es un recurso virtual y, a diferencia de un clúster de Dataproc en Compute Engine, no incluye máquinas virtuales de maestro y de trabajador de Dataproc independientes.

Dataproc en GKE crea grupos de nodos en un clúster de GKE cuando creas un clúster virtual de Dataproc en GKE.
Las tareas de Dataproc en GKE se ejecutan como pods en estos grupos de nodos. GKE gestiona los grupos de nodos y la programación de los pods en los grupos de nodos.
Crea varios clústeres virtuales. Puedes crear y ejecutar varios clústeres virtuales en un clúster de GKE para mejorar el uso de los recursos compartiendo grupos de nodos entre los clústeres virtuales.
- Cada clúster virtual:
  - se crea con propiedades independientes, como la versión del motor de Spark y la identidad de carga de trabajo
  - está aislado en un espacio de nombres de GKE independiente en el clúster de GKE

Consola

En la Google Cloud consola, ve a la página de Dataproc Clústeres.

Ir a Clústeres
Haz clic en Crear clúster.
En el cuadro de diálogo Crear clúster de Dataproc, haz clic en Crear en la fila Clúster en GKE.
En el panel Configurar clúster:
1. En el campo Nombre del clúster, introduce un nombre para el clúster.
2. En la lista Región, selecciona una región para el clúster virtual de Dataproc en GKE. Esta región debe ser la misma en la que se encuentra tu clúster de GKE (que seleccionarás en el siguiente paso).
3. En el campo Kubernetes Cluster (Clúster de Kubernetes), haz clic en Browse (Buscar) para seleccionar la región en la que se encuentra tu clúster de GKE.
4. Opcional: En el campo Segmento de almacenamiento provisional de Cloud Storage, puedes hacer clic en Examinar para seleccionar un segmento de Cloud Storage. Dataproc en GKE almacenará los artefactos en el segmento. Ignore este campo para que Dataproc en GKE cree un segmento de almacenamiento provisional.
En el panel de la izquierda, haz clic en Configurar grupos de nodos y, a continuación, en el panel Grupos de nodos, haz clic en Añadir un grupo.
1. Para reutilizar un grupo de nodos de Dataproc en GKE:
  1. Haz clic en Reutilizar grupo de nodos.
  2. Introduce el nombre del grupo de nodos y selecciona su rol. Al menos un grupo de nodos debe tener el rol DEFAULT.
  3. Haz clic en Listo.
2. Para crear un grupo de nodos de Dataproc en GKE, sigue estos pasos:
  1. Haz clic en Crear un nuevo grupo de nodos.
  2. Introduce los siguientes valores del grupo de nodos:
    - Nombre de grupo de nodos
    - Rol: al menos un grupo de nodos debe tener el rol DEFAULT.
    - Ubicación: especifica una zona de la región del clúster de Dataproc en GKE.
    - Tipo de máquina del grupo de nodos
    - Plataforma de CPU
    - Capacidad de desalojo
    - Mín.: número mínimo de nodos.
    - Máximo: número máximo de nodos. El número máximo de nodos debe ser superior a 0.
3. Haz clic en Añadir un grupo para añadir más grupos de nodos. Todos los grupos de nodos deben tener la ubicación. Puedes añadir un total de cuatro grupos de nodos.
(Opcional) Si has configurado un servidor de historial persistente (PHS) de Dataproc para ver el historial de tareas de Spark en clústeres de Dataproc en GKE activos y eliminados, haz clic en Personalizar clúster. A continuación, en el campo Clúster del servidor de historial, busca y elige tu clúster de PHS. El clúster de PHS debe estar ubicado en la misma región que el clúster virtual de Dataproc en GKE.
Haz clic en Crear para crear el clúster de Dataproc. Tu clúster de Dataproc en GKE aparece en una lista en la página Clusters (Clústeres). Su estado es Provisioning (Provisionando) hasta que el clúster esté listo para usarse. Después, el estado cambia a Running (En ejecución).

gcloud

Define variables de entorno y, a continuación, ejecuta el comando gcloud dataproc clusters gke create localmente o en Cloud Shell para crear un clúster de Dataproc en GKE.

Define las variables de entorno:
```
DP_CLUSTER=Dataproc on GKE  cluster-name \
  REGION=region \
  GKE_CLUSTER=GKE cluster-name \
  BUCKET=Cloud Storage bucket-name \
  DP_POOLNAME=node pool-name
  PHS_CLUSTER=Dataproc PHS server name
```
Notas:
- DP_CLUSTER: define el nombre del clúster virtual de Dataproc, que debe empezar por una letra minúscula seguida de un máximo de 54 letras minúsculas, números o guiones. No puede terminar en un guion.
- REGION: el region debe ser el mismo que la región en la que se encuentra el clúster de GKE.
- GKE_CLUSTER: el nombre del clúster de GKE.
- BUCKET: (Opcional) Puede especificar el nombre de un segmento de Cloud Storage que Dataproc usará para organizar los artefactos. Si no especificas un segmento, Dataproc en GKE creará uno de almacenamiento provisional.
- DP_POOLNAME: nombre del grupo de nodos que se va a crear en el clúster de GKE.
- PHS_CLUSTER: (Opcional) Servidor PHS de Dataproc para ver el historial de tareas de Spark en clústeres de Dataproc en GKE activos y eliminados. El clúster de PHS debe estar ubicado en la misma región que el clúster virtual de Dataproc en GKE.
Ejecuta el comando:
```
gcloud dataproc clusters gke create ${DP_CLUSTER} \
    --region=${REGION} \
    --gke-cluster=${GKE_CLUSTER} \
    --spark-engine-version=latest \
    --staging-bucket=${BUCKET} \
    --pools="name=${DP_POOLNAME},roles=default" \
    --setup-workload-identity \
    --history-server-cluster=${PHS_CLUSTER}
```
Notas:
- --spark-engine-version: la versión de la imagen de Spark que se usa en el clúster de Dataproc. Puedes usar un identificador, como 3, 3.1 o latest, o especificar la versión secundaria completa, como 3.1-dataproc-5.
- --staging-bucket: elimina esta marca para que Dataproc en GKE cree un bucket de almacenamiento provisional.
- --pools: esta marca se usa para especificar un grupo de nodos nuevo o ya creado que Dataproc creará o usará para llevar a cabo la carga de trabajo. Lista de ajustes del grupo de nodos de Dataproc en GKE separados por comas. Por ejemplo:
```
--pools=name=dp-default,roles=default,machineType=e2-standard-4,min=0,max=10
```
  Debes especificar el name y el role del grupo de nodos. El resto de los ajustes del grupo de nodos son opcionales. Puedes usar varias marcas --pools para especificar varios grupos de nodos. Al menos un grupo de nodos debe tener el rol default. Todos los grupos de nodos deben tener la misma ubicación.
- --setup-workload-identity: esta marca habilita las vinculaciones de Workload Identity. Estas vinculaciones permiten que las cuentas de servicio de Kubernetes (KSAs) actúen como la cuenta de servicio de VM de Dataproc (identidad del plano de datos) predeterminada del clúster virtual.
  Necesitas permisos elevados para definir la identidad de carga de trabajo en una cuenta de servicio de Google (GSA). Consulta los permisos de gestión de identidades y accesos de Dataproc en Google Kubernetes Engine. Para usar tu propia cuenta de servicio gestionada con tu clúster virtual de Dataproc en GKE, consulta Configuración personalizada de IAM.

REST

Completa un virtualClusterConfig como parte de una solicitud cluster.create de la API de Dataproc.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

PROJECT: ID de proyecto de Google Cloud
REGION: región del clúster virtual de Dataproc (la misma región que la del clúster de GKE)
DP_CLUSTER: nombre del clúster de Dataproc
GKE_CLUSTER: nombre del clúster de GKE
NODE_POOL: nombre del grupo de nodos.
PHS_CLUSTER: Nombre del clúster del servidor de historial persistente (PHS)
BUCKET: (Opcional) Nombre del bucket de almacenamiento provisional. Déjelo vacío para que Dataproc en GKE cree un segmento de almacenamiento provisional.

Método HTTP y URL:

POST https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters

Cuerpo JSON de la solicitud:

{
  "clusterName":"DP_CLUSTER",
  "projectId":"PROJECT",
  "virtualClusterConfig":{
    "auxiliaryServicesConfig":{
      "sparkHistoryServerConfig":{
        "dataprocCluster":"projects/PROJECT/regions/REGION/clusters/PHS_CLUSTER"
      }
    },
    "kubernetesClusterConfig":{
      "gkeClusterConfig":{
        "gkeClusterTarget":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER",
        "nodePoolTarget":[
          {
"nodePool":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER/nodePools/NODE_POOL",
            "roles":[
              "DEFAULT"
            ]
          }
        ]
      },
      "kubernetesSoftwareConfig":{
        "componentVersion":{
          "SPARK":"latest"
        }
      }
    },
    "stagingBucket":"BUCKET"
  }
}

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters"

PowerShell (Windows)

Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://dataproc.googleapis.com/v1/projects/project-id/regions/region/clusters" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "projectId":"PROJECT",
  "clusterName":"DP_CLUSTER",
  "status":{
    "state":"RUNNING",
    "stateStartTime":"2022-04-01T19:16:39.865716Z"
  },
  "clusterUuid":"98060b77-...",
  "statusHistory":[
    {
      "state":"CREATING",
      "stateStartTime":"2022-04-01T19:14:27.340544Z"
    }
  ],
  "labels":{
    "goog-dataproc-cluster-name":"DP_CLUSTER",
    "goog-dataproc-cluster-uuid":"98060b77-...",
    "goog-dataproc-location":"REGION",
    "goog-dataproc-environment":"prod"
  },
  "virtualClusterConfig":{
    "stagingBucket":"BUCKET",
    "kubernetesClusterConfig":{
      "kubernetesNamespace":"dp-cluster",
      "gkeClusterConfig":{
"gkeClusterTarget":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER",
        "nodePoolTarget":[
          {
"nodePool":"projects/PROJECT/locations/REGION/clusters/GKE_CLUSTER/nodePools/NODE_POOL",
            "roles":[
              "DEFAULT"
            ]
          }
        ]
      },
      "kubernetesSoftwareConfig":{
        "componentVersion":{
          "SPARK":"3.1-..."
        },
        "properties":{
          "dpgke:dpgke.unstable.outputOnly.endpoints.sparkHistoryServer":"https://...",
          "spark:spark.eventLog.dir":"gs://BUCKET/.../spark-job-history",
          "spark:spark.eventLog.enabled":"true"
        }
      }
    },
    "auxiliaryServicesConfig":{
      "sparkHistoryServerConfig":{
        "dataprocCluster":"projects/PROJECT/regions/REGION/clusters/PHS_CLUSTER"
      }
    }
  }

Enviar una tarea de Spark

Una vez que el clúster virtual de Dataproc en GKE esté en funcionamiento, envía un trabajo de Spark mediante la consola de Google Cloud , la CLI de gcloud o la API de Dataproc jobs.submit (mediante solicitudes HTTP directas o las bibliotecas de cliente de Cloud).

Ejemplo de trabajo de Spark de la CLI de gcloud:

gcloud dataproc jobs submit spark \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    --class=org.apache.spark.examples.SparkPi \
    --jars=local:///usr/lib/spark/examples/jars/spark-examples.jar \
    -- 1000

Ejemplo de tarea de PySpark de gcloud CLI:

gcloud dataproc jobs submit pyspark \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    local:///usr/lib/spark/examples/src/main/python/pi.py \
    -- 10

Ejemplo de trabajo de SparkR de gcloud CLI:

gcloud dataproc jobs submit spark-r \
    --region=${REGION} \
    --cluster=${DP_CLUSTER} \
    local:///usr/lib/spark/examples/src/main/r/dataframe.R

Limpieza

Elimina cualquiera de los siguientes recursos utilizados en esta guía de inicio rápido que no quieras seguir usando.
Elimina el clúster de Dataproc en GKE.
Elimina los grupos de nodos que utilice el clúster de Dataproc en GKE.
Elimina el clúster de GKE.