O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Implantação de demonstração

A implantação de demonstração oferece uma experiência simplificada usando um conjunto de dados de amostra bruto predefinido. Ela oferece um fluxo de trabalho completo para implantar os pipelines do Dataform do Cortex Framework para orquestração e inicializar os conjuntos de dados correspondentes do BigQuery com dados de amostra.

Antes de começar

Verifique se você atende aos pré-requisitos descritos na página Pré-requisitos antes de continuar com a implantação de demonstração.

Receber os papéis e permissões do IAM necessários

Receba as permissões do Identity and Access Management (IAM) necessárias para implantar o conteúdo do Cortex Framework no target Google Cloud project.

Papéis para o projeto de destino

Para receber as permissões necessárias para implantar o Cortex Framework, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto de destino:

Usuário de jobs do BigQuery (roles/bigquery.jobUser)
Editor de dados do BigQuery (roles/bigquery.dataEditor)
Administrador do Dataform (roles/dataform.admin)
Consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Para conceder os papéis solicitados a um usuário, use o script:

# 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: receber os papéis do IAM necessários para uma implantação de demonstração usando uma conta de serviço

Os papéis a seguir são necessários apenas para uma implantação de demonstração com o parâmetro opcional --service_account ativado. Fornecer uma conta de serviço simplifica as tarefas pós-implantação, configurando o agendamento dos pipelines de dados. É possível acionar manualmente essa configuração de fluxo de trabalho no Dataform na guia Release and Scheduling usando o menu de três pontos.

Para receber as permissões necessárias para implantar a demonstração do Cortex Framework, peça ao administrador para conceder a você o papel do IAM de criador de token da conta de serviço (roles/iam.serviceAccountTokenCreator) no projeto de origem e de destino. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Para criar a conta de serviço e conceder os papéis necessários, use o script a seguir:

# 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

Implantação

Siga estas etapas para criar um ambiente Python virtual, sincronizar as dependências e acionar os pipelines de dados. Lembre-se de usar os scripts uv do Cortex Framework para criar e enviar seus recursos de dados para o seu Google Cloud projeto, transformando as configurações locais em uma arquitetura de dados ativa e escalonável. Para mais informações, consulte a uv instalação na seção Pré-requisitos.

Executar a implantação de demonstração

Execute o comando a seguir para acionar a implantação. Esse processo vai realizar as seguintes ações:

Verificar se todos os pré-requisitos foram atendidos.
Carregar dados de amostra em um conjunto de dados do BigQuery para servir como a camada bruta para fins de demonstração.
Criar pipelines do Dataform para processar os dados de amostra nas camadas de dados do Cortex Framework.
Criar o repositório e o espaço de trabalho do Dataform e, em seguida, sincronizar os artefatos compilados com o repositório. *Opcional: se a conta de serviço tiver sido fornecida com --service_account, crie o agendamento do fluxo de trabalho e acione a execução inicial do fluxo de trabalho do Dataform.

Para a implantação de demonstração com valores padrão, execute o seguinte comando:

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

Para a implantação de demonstração com uma conta de serviço, execute o seguinte comando:

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

Verificação

Quando a implantação for concluída:

Abra o Dataform para inspecionar o novo código criado no repositório:
1. Repositório do Dataform criado: cortex-framework-demo
2. Dentro do repositório do Dataform, o espaço de trabalho de desenvolvimento: demo
3. Código compilado e sincronizado (é possível conferir o gráfico clicando em Compiled graph).
Execução manual de ações do Dataform:
1. Abra o espaço de trabalho do Dataform: "demo" do repositório cortex-framework-demo no Google Cloud console do Dataform.
2. Clique em Iniciar execução.
3. Selecione Executar ações.
4. Clique em Todas as ações.
5. Clique em Iniciar execução.
6. Monitore a execução bem-sucedida de todas as ações no repositório do Dataform usando a guia Registros de execução do fluxo de trabalho.
Execução de ações programadas do Dataform

Aplicável apenas se você estiver usando os parâmetros --service_account e --create_workflow_configs durante a implantação:

Abra o repositório do Dataform cortex-framework-demo no Google Cloud console do Dataform.
Clique em Releases &scheduling
Na seção Workflow configurations , clique no menu de três pontos da ação que você quer executar e clique em Start now.
Monitore a execução bem-sucedida de todas as ações no repositório do Dataform usando a guia Registros de execução do fluxo de trabalho.
Navegue até o console do BigQuery e clique em Datasets para conferir os conjuntos de dados recém-criados e verificar o esquema e os dados. Conjuntos de dados criados:
- cortex_demo_sap_s4_raw: esse conjunto de dados contém os dados brutos do sistema de origem (neste exemplo, SAP S/4HANA).
- cortex_demo_sap_s4_data_foundation: esse conjunto de dados representa a camada de base de dados, em que os dados brutos da camada bruta são processados pelo CDC.
- cortex_demo_data_product: esse conjunto de dados contém os produtos de dados de demonstração, visualizações ou tabelas refinadas e de alta performance projetadas para o consumo do usuário final.
- cortex_demo_samples: esse conjunto de dados contém os dados de demonstração para produtos de dados de consumo de amostra.

Limpar recursos de implantação de demonstração

Após uma implantação de demonstração bem-sucedida, é possível remover os recursos usados Google Cloud para evitar cobranças contínuas. O script a seguir exclui os conjuntos de dados do BigQuery criados, o espaço de trabalho do Dataform e o repositório do 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óximas etapas

Siga a Implantação de produção para saber como implantar o Google Cloud Cortex Framework em ambientes de produção.
Leia sobre a Integração do sistema de origem para saber como conectar seus sistemas de produção.