Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Implementación de demostración

La implementación de demostración ofrece una experiencia optimizada con un conjunto de datos de muestra sin procesar predefinido. Proporciona un flujo de trabajo de extremo a extremo para implementar las canalizaciones de Dataform de Cortex Framework para la organización y para inicializar los conjuntos de datos de BigQuery correspondientes con datos de muestra.

Antes de comenzar

Asegúrate de haber completado los requisitos previos que se describen en la página Requisitos previos antes de continuar con la implementación de demostración.

Obtén los roles y permisos de IAM necesarios

Obtén los permisos necesarios de Identity and Access Management (IAM) para implementar el contenido de Cortex Framework en el target Google Cloud project.

Roles para el proyecto de destino

Para obtener los permisos que necesitas para implementar Cortex Framework, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto de destino:

Usuario de trabajo de BigQuery (roles/bigquery.jobUser)
Editor de datos de BigQuery (roles/bigquery.dataEditor)
Administrador de Dataform (roles/dataform.admin)
Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Para otorgar los roles solicitados a un usuario, puedes usar la secuencia de comandos:

# Grant BigQuery JobUser to the user
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_EMAIL" \
        --role="roles/bigquery.jobUser"

# Grant BigQuery DataEditor to the user
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_EMAIL" \
        --role="roles/bigquery.dataEditor"

# Grant BigQuery Dataform admin to the user
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_EMAIL" \
        --role="roles/dataform.admin"

# Grant Service Usage Consumer to the user
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_EMAIL" \
        --role="roles/serviceusage.serviceUsageConsumer"

Opcional: Obtén los roles de IAM necesarios para una implementación de demostración con una cuenta de servicio

Los siguientes roles solo son necesarios para una implementación de demostración con el parámetro opcional --service_account habilitado. Proporcionar una cuenta de servicio simplifica las tareas posteriores a la implementación, ya que configura la programación de las canalizaciones de datos. Puedes activar manualmente esta configuración de flujo de trabajo en Dataform en la pestaña Release and Scheduling con el menú de tres puntos.

Para obtener los permisos que necesitas para implementar la demostración de Cortex Framework, pídele a tu administrador que te otorgue el rol de IAM Creador de tokens de cuenta de servicio (roles/iam.serviceAccountTokenCreator) en tu proyecto de origen y de destino. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Para crear la cuenta de servicio y otorgar los roles necesarios, puedes usar la siguiente secuencia de comandos:

# Create the service account
gcloud iam service-accounts create cortex-dataform \
        --description="Service account for Cortex Dataform execution" \
        --display-name="Cortex Dataform Service Account" \
        --project=PROJECT_ID

# Wait for the service account to propagate (IAM eventual consistency)
sleep 10

# Grant BigQuery DataEditor to the service account
gcloud projects add-iam-policy-binding PROJECT_ID \
        --member="serviceAccount:cortex-dataform@PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/bigquery.dataEditor"

# Grant BigQuery jobUser to the service account
gcloud projects add-iam-policy-binding PROJECT_ID \
        --member="serviceAccount:cortex-dataform@PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/bigquery.jobUser"

# Grant Dataform Editor to the service account
gcloud projects add-iam-policy-binding PROJECT_ID \
        --member="serviceAccount:cortex-dataform@PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/dataform.editor"

# Grant the user Service Account Token Creator role on the Cortex service account
gcloud iam service-accounts add-iam-policy-binding \
        cortex-dataform@PROJECT_ID.iam.gserviceaccount.com \
        --member="user:USER_EMAIL" \
        --role="roles/iam.serviceAccountTokenCreator" \
        --project=PROJECT_ID

PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")

## Note: In case the commands below should fail with message: 
# "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-dataform.iam.gserviceaccount.com" not found
# the default dataform service accounts hasn't been yet provisioned for given project.
# In such case, please execute the commands after initial run of `uv run cortex-*`

# Grant the Dataform Service Account the Token Creator role on the Cortex service account
gcloud iam service-accounts add-iam-policy-binding \
        cortex-dataform@PROJECT_ID.iam.gserviceaccount.com \
        --member="serviceAccount:service-$PROJECT_NUMBER@gcp-sa-dataform.iam.gserviceaccount.com" \
        --role="roles/iam.serviceAccountTokenCreator" \
        --project=PROJECT_ID

# Grant the Dataform Service Account the Service Account User role on the Cortex service account
gcloud iam service-accounts add-iam-policy-binding \
        cortex-dataform@PROJECT_ID.iam.gserviceaccount.com \
        --member="serviceAccount:service-$PROJECT_NUMBER@gcp-sa-dataform.iam.gserviceaccount.com" \
        --role="roles/iam.serviceAccountUser" \
        --project=PROJECT_ID

Deployment

Sigue estos pasos para crear un entorno virtual de Python, sincronizar las dependencias y activar las canalizaciones de datos. Recuerda usar las secuencias de comandos uv de Cortex Framework para compilar y enviar tus recursos de datos a tu Google Cloud proyecto, lo que transforma tus configuraciones locales en una arquitectura de datos activa y escalable. Para obtener más información, consulta la uv instalación en la sección Requisitos previos.

Ejecuta la implementación de demostración

Ejecuta el siguiente comando para activar la implementación. Este proceso realizará las siguientes acciones:

Verifica que se hayan completado todos los requisitos previos.
Carga datos de muestra en un conjunto de datos de BigQuery para que sirvan como capa sin procesar para fines de demostración.
Compila canalizaciones de Dataform para procesar los datos de muestra a través de las capas de datos de Cortex Framework.
Crea el repositorio y el espacio de trabajo de Dataform y, luego, sincroniza los artefactos compilados con el repositorio. *Opcional: Si se proporcionó una cuenta de servicio con --service_account, crea una programación de flujo de trabajo y activa la ejecución inicial del flujo de trabajo de Dataform.

Para la implementación de demostración con valores predeterminados, ejecuta el siguiente comando:

uv run cortex-demo --project_id=PROJECT_ID --sap_version s4

Para la implementación de demostración con una cuenta de servicio, ejecuta el siguiente comando:

uv run cortex-demo --project_id=PROJECT_ID \
  --service_account="cortex-dataform@PROJECT_ID.iam.gserviceaccount.com" \
  --create_workflow_configs

Verificación

Una vez que se complete la implementación, haz lo siguiente:

Abre Dataform para inspeccionar el código nuevo creado en el repositorio:
1. Repositorio de Dataform creado: cortex-framework-demo
2. Dentro del repositorio de Dataform, el espacio de trabajo de desarrollo: demo
3. Código compilado y sincronizado (puedes ver el gráfico si haces clic en Compiled graph).
Ejecución manual de acciones de Dataform:
1. Abre el espacio de trabajo de Dataform: "demo" desde el repositorio cortex-framework-demo en Google Cloud la consola de Dataform.
2. Haz clic en Iniciar ejecución.
3. Haz clic en Ejecutar acciones.
4. Haz clic en Todas las acciones.
5. Haz clic en Iniciar ejecución.
6. Supervisa la ejecución correcta de todas las acciones en tu repositorio de Dataform con la pestaña Workflow Execution Logs.
Ejecución programada de acciones de Dataform

Se aplica solo en caso de que hayas usado los parámetros --service_account y --create_workflow_configs durante la implementación:

Abre el repositorio de Dataform cortex-framework-demo en Google Cloud la consola de Dataform.
Haz clic en Releases &scheduling.
En la sección Workflow configurations , haz clic en el menú de tres puntos de la acción que te interesa ejecutar y, luego, en Start now.
Supervisa la ejecución correcta de todas las acciones en tu repositorio de Dataform con la pestaña Workflow Execution Logs.
Navega a la consola de BigQuery y haz clic en Datasets para ver los conjuntos de datos recién creados y verificar el esquema y los datos. Conjuntos de datos creados:
- cortex_demo_sap_s4_raw: Este conjunto de datos contiene los datos sin procesar del sistema de origen (en este ejemplo, SAP S/4HANA).
- cortex_demo_sap_s4_data_foundation: Este conjunto de datos representa la capa de base de datos, en la que se procesan los datos sin procesar de la capa sin procesar con CDC.
- cortex_demo_data_product: Este conjunto de datos contiene los productos de datos de demostración: vistas o tablas refinadas y de alto rendimiento diseñadas para el consumo del usuario final.
- cortex_demo_samples: Este conjunto de datos contiene los datos de demostración para los productos de datos de consumo de muestra.

Limpia los recursos de la implementación de demostración

Después de una implementación de demostración exitosa, puedes quitar los recursos usados Google Cloud para evitar cargos continuos. La siguiente secuencia de comandos borra los conjuntos de datos de BigQuery creados, el espacio de trabajo de Dataform y el repositorio de Dataform:

#!/bin/bash

# Define variables using names from uv-run-cortex-demo.md
PROJECT_ID="PROJECT_ID"
SAP_VERSION="s4"

DATAFORM_REGION="us-central1"
SOURCE_SAP_RAW_DATASET_ID="cortex_demo_sap_s4_raw"
TARGET_SAP_FOUNDATION_DATASET_ID="cortex_demo_sap_s4_data_foundation"
if [[ "$SAP_VERSION" == "ecc" ]]; then
  SOURCE_SAP_RAW_DATASET_ID="cortex_demo_sap_ecc_raw"
  TARGET_SAP_FOUNDATION_DATASET_ID="cortex_demo_sap_ecc_data_foundation"
fi
TARGET_DP_DATASET_ID="cortex_demo_data_product"
TARGET_SAMPLES_DATASET_ID="cortex_demo_samples"
REPOSITORY_NAME="cortex-framework-demo"
WORKSPACE_NAME="demo"
SERVICE_ACCOUNT_NAME="cortex-dataform"


# Color codes for formatting status output
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
RED='\033[0;31m'
NC='\033[0m' # No Color

# Helper function to delete a resource and report status
delete_resource() {
    local label=$1
    local url=$2
    local resource_type=$3
    
    echo -n "${label}... "
    
    local temp_file=$(mktemp)
    local code=$(curl -s -o "${temp_file}" -w "%{http_code}" -X DELETE \
        -H "Authorization: Bearer ${ACCESS_TOKEN}" \
        "${url}")
        
    if [ "$code" -eq 200 ] || [ "$code" -eq 204 ]; then
        echo -e "${GREEN}ok${NC}"
    elif [ "$code" -eq 404 ]; then
        echo -e "${YELLOW}skipped, ${resource_type} not found${NC}"
    else
        echo -e "${RED}failed (HTTP ${code})${NC}"
        if [ -s "${temp_file}" ]; then
            echo "  Error details:"
            sed 's/^/    /' "${temp_file}"
        fi
    fi
    rm -f "${temp_file}"
}

echo "Deleting BigQuery datasets..."
for DATASET_ID in "${SOURCE_SAP_RAW_DATASET_ID}" \
                  "${TARGET_SAP_FOUNDATION_DATASET_ID}" \
                  "${TARGET_DP_DATASET_ID}" \
                  "${TARGET_SAMPLES_DATASET_ID}"; do
    echo "deleting ${PROJECT_ID}:${DATASET_ID}"
    bq rm -r -f "${PROJECT_ID}:${DATASET_ID}"
done

ACCESS_TOKEN=$(gcloud auth print-access-token)
delete_resource "Deleting Dataform workspace ${WORKSPACE_NAME}" \
    "https://dataform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/${DATAFORM_REGION}/repositories/${REPOSITORY_NAME}/workspaces/${WORKSPACE_NAME}" \
    "workspace"

echo "Deleting Dataform workflow configurations..."
WORKFLOW_CONFIGS_JSON=$(curl -s -H "Authorization: Bearer ${ACCESS_TOKEN}" \
    "https://dataform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/${DATAFORM_REGION}/repositories/${REPOSITORY_NAME}/workflowConfigs")

WORKFLOW_CONFIGS=$(echo "${WORKFLOW_CONFIGS_JSON}" | grep '"name":' | sed -E 's/.*"name": "([^"]+)".*/\1/')

if [ -z "${WORKFLOW_CONFIGS}" ]; then
    echo -e "  No workflow configurations found. ${YELLOW}skipped${NC}"
else
    for config in ${WORKFLOW_CONFIGS}; do
        delete_resource "  Deleting workflow config: ${config##*/}" \
            "https://dataform.googleapis.com/v1beta1/${config}" \
            "workflow config"
    done
fi

echo "Deleting Dataform release configurations..."
RELEASE_CONFIGS_JSON=$(curl -s -H "Authorization: Bearer ${ACCESS_TOKEN}" \
    "https://dataform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/${DATAFORM_REGION}/repositories/${REPOSITORY_NAME}/releaseConfigs")

RELEASE_CONFIGS=$(echo "${RELEASE_CONFIGS_JSON}" | grep '"name":' | sed -E 's/.*"name": "([^"]+)".*/\1/')

if [ -z "${RELEASE_CONFIGS}" ]; then
    echo -e "  No release configurations found. ${YELLOW}skipped${NC}"
else
    for config in ${RELEASE_CONFIGS}; do
        delete_resource "  Deleting release config: ${config##*/}" \
            "https://dataform.googleapis.com/v1beta1/${config}" \
            "release config"
    done
fi

delete_resource "Deleting Dataform repository ${REPOSITORY_NAME}" \
    "https://dataform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/${DATAFORM_REGION}/repositories/${REPOSITORY_NAME}?force=true" \
    "repository"

if gcloud iam service-accounts describe "${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" --project="${PROJECT_ID}" >/dev/null 2>&1; then
    read -p "Do you want to delete the service account ${SERVICE_ACCOUNT_NAME}? (y/N): " -r
    if [[ "$REPLY" =~ ^[Yy]$ ]]; then
        echo -n "Deleting service account ${SERVICE_ACCOUNT_NAME}... "
        ERROR_MSG=$(gcloud iam service-accounts delete "${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" --project="${PROJECT_ID}" --quiet 2>&1)
        EXIT_CODE=$?
        if [ ${EXIT_CODE} -eq 0 ]; then
            echo -e "${GREEN}ok${NC}"
        else
            echo -e "${RED}failed${NC}"
            echo "  Error details:"
            echo "${ERROR_MSG}" | sed 's/^/    /'
        fi
    else
        echo -e "Deleting service account ${SERVICE_ACCOUNT_NAME}... ${YELLOW}skipped (user cancelled)${NC}"
    fi
else
    echo -e "Deleting service account ${SERVICE_ACCOUNT_NAME}... ${YELLOW}skipped, service account not found${NC}"
fi

echo "Cortex Framework demo deployment cleanup complete."

Próximos pasos

Sigue la Implementación de producción para aprender a implementar Google Cloud Cortex Framework en entornos de producción.
Lee sobre la Integración del sistema de origen para aprender a conectar tus sistemas de producción.