Se usó la API de Cloud Translation para traducir esta página.

Ejecuta un trabajo de Spark en Dataproc en Google Kubernetes Engine

Antes de comenzar

Debes haber creado un estándar (no Autopilot) Clúster zonal o regional de Google Kubernetes Engine (GKE) que tenga Workload Identity habilitado en el clúster.
Sugerencia de rendimiento: Habilita transmisión de imágenes para acelerar la inicialización de la carga de trabajo.

Crea un clúster virtual de Dataproc on GKE

Se crea un clúster virtual de Dataproc on GKE como plataforma de implementación para Componentes de Dataproc. Es un recurso virtual y, a diferencia de Dataproc en el clúster de Compute Engine, no incluye Dataproc independiente VMs de instancia principal y de trabajador.

Dataproc en GKE crea grupos de nodos dentro de un clúster cuando creas un clúster virtual de Dataproc on GKE.
Los trabajos de Dataproc en GKE se ejecutan como Pods en estos grupos de nodos. Los grupos de nodos y la programación de Pods en los grupos de nodos.
Crea varios clústeres virtuales. Puedes crear y ejecutar múltiples clústeres en un clúster de GKE para obtener la utilización de recursos compartiendo grupos de nodos en los clústeres virtuales.
- Cada clúster virtual realiza las siguientes acciones:
  - se crea con propiedades separadas, como Spark versión de motor y Workload Identity
  - está aislada en un espacio de nombres de GKE independiente en el clúster de GKE

Console

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

Ir a los clústeres
Haga clic en Crear clúster.
En el diálogo Crear clúster de Dataproc, haz clic en Crear. la fila Clúster en GKE.
En el panel Configurar clúster:
1. En el campo Nombre del clúster, ingresa un nombre para el clúster.
2. En la lista Región, selecciona una región para el clúster virtual de Dataproc on GKE. Esta región debe ser la misma región en la que se encuentra tu clúster de GKE existente (el cual seleccionarás en el siguiente elemento).
3. En el campo Clúster de Kubernetes, haz clic en Explorar para seleccionar la región en la que se encuentra tu clúster de GKE existente.
4. Opcional: En el campo Bucket de etapa de pruebas de Cloud Storage, puedes hacer clic en Explora para seleccionar un bucket de Cloud Storage existente. Dataproc en GKE organizará los artefactos en el bucket. Ignorar para que Dataproc en GKE cree un bucket de etapa de pruebas.
En el panel izquierdo, haz clic en Configurar grupos de nodos y, luego, en Grupos de nodos. haz clic en Add a pool (Agregar un grupo).
1. Para volver a usar un grupo de nodos existente de Dataproc en GKE, haz lo siguiente:
  1. Haz clic en Reutilizar grupo de nodos existente.
  2. Ingresa el nombre del grupo de nodos existente y selecciona su Rol. Al menos un grupo de nodos debe tener el rol DEFAULT.
  3. Haz clic en Listo.
2. Para crear un nuevo grupo de nodos de Dataproc on GKE, sigue estos pasos:
  1. Haz clic en Crear un nuevo grupo de nodos.
  2. Ingresa los siguientes valores del grupo de nodos:
    - Nombre del grupo de nodos
    - Rol: Al menos un grupo de nodos debe tener el rol DEFAULT.
    - Ubicación: Especifica una zona dentro de la región del clúster de Dataproc en GKE.
    - Tipo de máquina del grupo de nodos
    - Plataforma de CPU
    - Prioridad
    - Min: La cantidad mínima de nodos.
    - Máx.: La cantidad máxima de nodos. La cantidad máxima de nodos debe ser superior a 0.
3. Haz clic en Agregar un grupo para agregar más grupos de nodos. Todas los grupos de nodos deben tener la ubicación. Puedes agregar un total de cuatro grupos de nodos.
(Opcional) Si configuraste un servidor de historial persistente (PHS) de Dataproc para ver el historial de trabajos de Spark en Dataproc on GKE activo y borrado clústeres, haz clic en Personalizar clúster. Luego, en el clúster de 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 on GKE.
Haz clic en Crear para generar el clúster de Dataproc. Tu El clúster de Dataproc en GKE aparece en una lista en la página Clústeres. Su estado es Provisioning hasta que el clúster esté listo para usarse. entonces el estado cambia a Running.

gcloud

Configura las variables de entorno y, luego, ejecuta gcloud dataproc clusters gke create de forma local o en Cloud Shell para crear un clúster de Dataproc en GKE.

Configura 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: Establece el nombre del clúster virtual de Dataproc, que debe comenzar con una letra minúscula seguida por hasta 54 letras minúsculas, números o guiones. No puede terminar con un guion.
- REGION: region debe ser la misma que la región en la que se encuentra el clúster de GKE.
- GKE_CLUSTER: Es el nombre del clúster de GKE existente.
- BUCKET: Puedes especificar el nombre de un elemento (opcional). Bucket de Cloud Storage, que Dataproc usará para almacenar los artefactos en etapa intermedia. Si no especificas un bucket, Dataproc en GKE creará un bucket de etapa de pruebas.
- DP_POOLNAME: Es el nombre de un grupo de nodos. crear en el clúster de GKE.
- PHS_CLUSTER: Servidor PHS de Dataproc (opcional) para ver el historial de trabajos de Spark en Dataproc en GKE activos y borrados entre los clústeres de Kubernetes. El clúster de PHS debe estar ubicado en la misma región que el Dataproc en el clúster virtual de GKE.
Ejecuta el siguiente 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: El Versión de la imagen de Spark que se usa en el clúster de Dataproc. Puedes usa un identificador, como 3, 3.1 o latest, o puedes especificar la versión submenor completa, como 3.1-dataproc-5
- --staging-bucket: Borra esta marca para tener Dataproc en GKE. crear un bucket de etapa de pruebas.
- --pools: Esta marca se usa para especificar un grupo de nodos nuevo o existente. que Dataproc creará o usará para realizar la carga de trabajo. Mostrar en lista Configuración 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 grupo de nodos name y role. Otro grupo de nodos de configuración 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 el mismo ubicación.
- --setup-workload-identity: Esta marca habilita Workload Identity y vinculaciones de IAM. Estas vinculaciones permiten que las cuentas de servicio de Kubernetes (KSA) para que actúe como configuración predeterminada Cuenta de servicio de VM de Dataproc (identidad del plano de datos) del clúster virtual.
  Necesitas permisos elevados para configurar Workload Identity en una cuenta de servicio de Google (GSA) (consulta Permisos de IAM de Dataproc en Google Kubernetes Engine). Para usar su propio GTFS con su clúster virtual de Dataproc on GKE, consulta Configuración de IAM personalizada.

REST

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

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT: ID del proyecto de Google Cloud
REGION: Es la región del clúster virtual de Dataproc (la misma región que la región del clúster de GKE existente).
DP_CLUSTER: Es el nombre del clúster de Dataproc.
GKE_CLUSTER: Es el 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: Es el nombre del bucket de etapa de pruebas (opcional). Deja este campo vacío para que Dataproc en GKE cree un bucket de etapa de pruebas.

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, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, 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 supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, 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 que se muestra a continuación:

{
  "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 un trabajo de Spark

Después de que se ejecute tu clúster virtual de Dataproc on GKE, enviar un trabajo de Spark con la consola de Google Cloud gcloud CLI o Dataproc jobs.submit (mediante solicitudes HTTP directas o el Bibliotecas cliente de Cloud).

Ejemplo de trabajo de gcloud CLI Spark:

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 trabajo de gcloud CLI en PySpark:

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 gcloud CLI SparkR:

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

Limpia

Borra cualquiera de los siguientes recursos usados en esta guía de inicio rápido que que no quieres seguir usando.
Borra el clúster de Dataproc en GKE.
Borra grupos de nodos que usa el clúster de Dataproc en GKE.
Borra el clúster de GKE.