Ler previsões do BigQuery ML no SAP usando o ABAP SDK for Google Cloud

1. Introdução

Neste codelab, você vai criar um modelo de machine learning (ML) no BigQuery e receber previsões desse modelo usando o SDK ABAP para Google Cloud.

Você vai usar os seguintes serviços do Google Cloud:

• BigQuery
• Cloud Shell

O que você vai criar

Você vai criar o seguinte:

• Um modelo de machine learning (ML) do BigQuery.
• Uma conta de serviço com o papel de usuário do job do BigQuery para chamar a API BigQuery.
• Um programa ABAP para chamar a API BigQuery e receber previsões do modelo de ML.

2. Requisitos

• Um navegador, como o Chrome ou o Firefox
• Um projeto do Google Cloud com o faturamento ativado ou Crie uma conta de teste sem custo financeiro de 90 dias para o Google Cloud Platform.
• GUI do SAP (Windows ou Java) instalado no sistema. Se o SAP GUI já estiver instalado no seu laptop, conecte-se ao SAP usando o endereço IP externo da VM como o IP do servidor de aplicativos. Se você estiver usando um Mac, também poderá instalar o SAP GUI para Java disponível neste link.

3. Antes de começar

• No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud (por exemplo: abap-sdk-poc).
• Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto. Pule esta etapa se você estiver usando a conta de teste sem custo financeiro de 90 dias.
• Você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud.
• No console do Cloud, clique em Ativar o Cloud Shell no canto superior direito:

• Execute os comandos a seguir no Cloud Shell para autenticar sua conta e definir o projeto padrão como abap-sdk-poc. A zona us-west4-b é usada como exemplo. Se necessário, mude o projeto e a zona nos comandos a seguir de acordo com sua preferência.

gcloud auth login
gcloud config set project abap-sdk-poc
gcloud config set compute/zone us-west4-b

• É necessário ter acesso a um sistema SAP com o SDK do ABAP para Google Cloud instalado.
• É necessário concluir o codelab 1 (Instalar o teste da plataforma ABAP 1909 no Google Cloud Platform e instalar o SDK ABAP para o Google Cloud) e o codelab 2 (Configurar a autenticação do SDK ABAP usando tokens para SAP hospedado na VM do Compute Engine) antes de prosseguir com este codelab.
• Se você concluiu o codelab 1 e o codelab 2, você teria um sistema de teste da plataforma ABAP 1909 no Google Cloud, além da configuração necessária para autenticação e conectividade.
• Se você não tiver concluído os codelabs 1 e 2, não terá toda a infraestrutura e conectividade necessárias para realizar as etapas fornecidas neste codelab. Portanto, você precisa concluir o codelab 1 e o codelab 2 antes de prosseguir com este codelab.

4. Ativar a API BigQuery V2 no seu projeto do Google Cloud

1. No console do Cloud, clique em Ativar o Cloud Shell no canto superior direito:

2. Execute os seguintes comandos no Cloud Shell para ativar a API BigQuery:

gcloud services enable bigquery.googleapis.com

Se a execução for bem-sucedida, uma mensagem será exibida, conforme mostrado abaixo.

Agora, a API BigQuery está ativada no seu projeto do Google Cloud.

5. Criar uma conta de serviço para acesso seguro ao BigQuery

Para receber previsões de ML de um modelo do BigQuery ML com segurança, é necessário criar uma conta de serviço com os papéis de Usuário do job do BigQuery e Leitor de dados do BigQuery. Isso permite que seu programa execute consultas (como jobs) no projeto e leia dados das tabelas. Esse papel concede apenas a permissão necessária para criar jobs e ler dados, minimizando os riscos de segurança.

Criar uma conta de serviço

Para criar uma conta de serviço com a função necessária, siga estas etapas:

1. Execute o seguinte comando no terminal do Cloud Shell:

gcloud iam service-accounts create abap-sdk-bigquery-jobuser --display-name="Service Account for BigQuery Job user"

Observação: se o comando acima for executado com sucesso, você vai receber a seguinte resposta:

Created service account [abap-sdk-biguqery-jobuser] .

2. Agora adicione os papéis necessários à conta de serviço criada na etapa anterior:

gcloud projects add-iam-policy-binding abap-sdk-poc --member='serviceAccount:[e-mail]' --role='roles/bigquery.jobUser'

gcloud projects add-iam-policy-binding abap-sdk-poc --member='serviceAccount:[e-mail]' --role='roles/bigquery.dataViewer'

O comando acima usa abap-sdk-poc como marcador de posição para o projeto do Google Cloud. Substitua abap-sdk-poc pelo ID do projeto.

3. Para verificar se o papel foi adicionado, acesse a página IAM. A conta de serviço que você criou vai aparecer com o papel atribuído a ela.

6. Como criar um modelo de machine learning do BigQuery

Neste codelab, vamos criar um modelo k-means para agrupar o conjunto de dados de locações de bicicletas de Londres. É possível aplicar o algoritmo k-means para agrupar seus dados em clusters. Ao contrário do machine learning supervisionado, que tem a ver com análise preditiva, o aprendizado não supervisionado tem a ver com análise descritiva. Trata-se de entender os dados para que seja possível tomar decisões orientadas a dados.

Criar o conjunto de dados

Para criar um conjunto de dados do BigQuery para armazenar seu modelo de ML, siga estas etapas:

1. No console do Google Cloud, acesse a página do BigQuery. Acessar a página do BigQuery
2. No painel Explorer, clique no nome do seu projeto.
3. Clique em Conferir ações > Criar conjunto de dados.

4. Na página Criar conjunto de dados, faça o seguinte:

• Para o código do conjunto de dados, insira bqml_tutorial.
• Em Tipo de local, selecione Multirregião e UE (várias regiões na União Europeia). O conjunto de dados público de Locações de Bicicletas de Londres é armazenado na multirregião da UE. O conjunto de dados precisa estar no mesmo local.
• Mantenha as configurações padrão restantes e clique em Criar conjunto de dados.

Criar um modelo k-means

Agora que o conjunto de dados está configurado, a próxima etapa é criar um modelo k-means usando os dados. É possível criar e treinar um modelo k-means usando a instrução CREATE MODEL com a opção model_type=kmeans.

Para executar a consulta e criar um modelo k-means, siga estas etapas:

1. Acessar a página do BigQuery. Acessar o BigQuery
2. No painel Editor, execute a seguinte instrução SQL:

CREATE OR REPLACE MODEL `bqml_tutorial.london_station_clusters`
  OPTIONS(model_type='kmeans', num_clusters=4) AS
WITH
  hs AS (
  SELECT
    h.start_station_name AS station_name,
  IF
    (EXTRACT(DAYOFWEEK
      FROM
        h.start_date) = 1
      OR EXTRACT(DAYOFWEEK
      FROM
        h.start_date) = 7,
      "weekend",
      "weekday") AS isweekday,
    h.duration,
    ST_DISTANCE(ST_GEOGPOINT(s.longitude,
        s.latitude),
      ST_GEOGPOINT(-0.1,
        51.5))/1000 AS distance_from_city_center
  FROM
    `bigquery-public-data.london_bicycles.cycle_hire` AS h
  JOIN
    `bigquery-public-data.london_bicycles.cycle_stations` AS s
  ON
    h.start_station_id = s.id
  WHERE
    h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP)
    AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ),
  stationstats AS (
  SELECT
    station_name,
    isweekday,
    AVG(duration) AS duration,
    COUNT(duration) AS num_trips,
    MAX(distance_from_city_center) AS distance_from_city_center
  FROM
    hs
  GROUP BY
    station_name, isweekday)
SELECT
  * EXCEPT(station_name, isweekday)
FROM
  stationstats

Observação: se o comando SQL acima for executado com sucesso, você vai receber a seguinte resposta:

O modelo chamado london_station_clusters foi criado.

3. No painel de navegação, na seção Recursos, expanda o nome do projeto, clique em bqml_tutorial e, depois, em london_station_clusters.
4. Clique na guia Esquema. O esquema do modelo lista os três atributos de estação que o BigQuery ML usou para realizar o agrupamento. O esquema será semelhante a este:

5. Clique na guia Avaliação. Essa guia mostra visualizações dos clusters identificados pelo modelo k-means. Em Recursos numéricos, os gráficos de barras mostram até 10 dos valores de atributos numéricos mais importantes para cada centroide. É possível selecionar quais recursos visualizar no menu suspenso.

7. Receber previsões do BigQuery ML usando o SDK ABAP for Google Cloud

Agora que você configurou os pré-requisitos no Google Cloud, está tudo pronto para concluir as etapas no seu sistema SAP e receber previsões do modelo de ML usando o SDK do ABAP para Google Cloud.

Criar configuração da chave do cliente

Para a configuração relacionada à autenticação e conectividade, o ABAP SDK for Google Cloud usa as tabelas /GOOG/CLIENT_KEY e /GOOG/SERVIC_MAP..

Para manter a configuração na tabela /GOOG/CLIENT_KEY, siga estas etapas:

1. Na GUI do SAP, insira o código da transação SPRO.
2. Clique em IMG de referência SAP.
3. Clique em ABAP SDK for Google Cloud > Configurações básicas > Configurar chave do cliente.

4. Mantenha os valores a seguir nos campos listados e deixe todos os outros campos em branco:

Campo	Valor
Nome da chave do Google Cloud	BIGQUERY_ML
Nome da conta de serviço do Google Cloud	[e-mail]
Escopo do Google Cloud	https://www.googleapis.com/auth/cloud-platform
ID do projeto	abap-sdk-poc
Classe de autorização	/GOOG/CL_AUTH_GOOGLE

Observação: a configuração da tabela /GOOG/SERVIC_MAP é opcional e pode ser ignorada neste caso.

Criar um relatório ABAP para receber previsões do modelo de ML do BigQuery

Para criar um relatório ABAP, siga estas etapas:

1. Na GUI do SAP, acesse o código de transação SE38 e crie um programa de relatório com o nome ZDEMO_BIGQUERY_ML_PREDICT..
2. No pop-up que abrir, forneça os detalhes, conforme mostrado na imagem a seguir:

3. No próximo pop-up, selecione Objeto local ou informe um nome de pacote, conforme apropriado.
4. No Editor ABAP, adicione o seguinte código:

REPORT zdemo_bigquery_ml_predict.

types:
  begin of lty_query_result,
    centroid_id     type i,
    station_name    type string,
    isweekday       type string,
    num_trips       type i,
    distance_from_city type string,
  end of lty_query_result,
  ltt_query_result type standard table of lty_query_result.

DATA:
  lv_project_id TYPE string,
  ls_input      TYPE /goog/cl_bigquery_v2=>ty_103,
  ls_output     TYPE lty_query_result,
  lt_output     TYPE ltt_query_result.

CONSTANTS:
  lc_newline TYPE c VALUE cl_abap_char_utilities=>newline.

TRY.
    "Initialize Bigquery object, pass the client key name that you have configured in /GOOG/CLIENT_KEY table
    DATA(lo_bq) = NEW /goog/cl_bigquery_v2( iv_key_name = 'BIGQUERY_ML' ).

    "Populate relevant parameters
    lv_project_id = lo_bq->gv_project_id.

    ls_input-default_dataset-project_id = 'abap-sdk-poc'.
    ls_input-default_dataset-dataset_id = 'bqml_tutorial'.

    "This query gets predictions from
    ls_input-query =
                | WITH | && lc_newline &&
                | hs AS ( | && lc_newline &&
                | SELECT | && lc_newline &&
                | h.start_station_name AS station_name, | && lc_newline &&
                | IF | && lc_newline &&
                | (EXTRACT(DAYOFWEEK | && lc_newline &&
                | FROM | && lc_newline &&
                | h.start_date) = 1 | && lc_newline &&
                | OR EXTRACT(DAYOFWEEK | && lc_newline &&
                | FROM | && lc_newline &&
                | h.start_date) = 7, | && lc_newline &&
                | "weekend", | && lc_newline &&
                | "weekday") AS isweekday, | && lc_newline &&
                | h.duration, | && lc_newline &&
                | ST_DISTANCE(ST_GEOGPOINT(s.longitude, | && lc_newline &&
                | s.latitude), | && lc_newline &&
                | ST_GEOGPOINT(-0.1, | && lc_newline &&
                | 51.5))/1000 AS distance_from_city_center | && lc_newline &&
                | FROM | && lc_newline &&
                | `bigquery-public-data.london_bicycles.cycle_hire` AS h | && lc_newline &&
                | JOIN | && lc_newline &&
                | `bigquery-public-data.london_bicycles.cycle_stations` AS s | && lc_newline &&
                | ON | && lc_newline &&
                | h.start_station_id = s.id | && lc_newline &&
                | WHERE | && lc_newline &&
                | h.start_date BETWEEN CAST('2015-01-01 00:00:00' AS TIMESTAMP) | && lc_newline &&
                | AND CAST('2016-01-01 00:00:00' AS TIMESTAMP) ), | && lc_newline &&
                | stationstats AS ( | && lc_newline &&
                | SELECT | && lc_newline &&
                | station_name, | && lc_newline &&
                | isweekday, | && lc_newline &&
                | AVG(duration) AS duration, | && lc_newline &&
                | COUNT(duration) AS num_trips, | && lc_newline &&
                | MAX(distance_from_city_center) AS distance_from_city_center | && lc_newline &&
                | FROM | && lc_newline &&
                | hs | && lc_newline &&
                | GROUP BY | && lc_newline &&
                | station_name, isweekday ) | && lc_newline &&
                | SELECT | && lc_newline &&
                | * EXCEPT(nearest_centroids_distance) | && lc_newline &&
                | FROM | && lc_newline &&
                | ML.PREDICT( MODEL `bqml_tutorial.london_station_clusters`, | && lc_newline &&
                | ( | && lc_newline &&
                | SELECT | && lc_newline &&
                | * | && lc_newline &&
                | FROM | && lc_newline &&
                | stationstats | && lc_newline &&
                | WHERE | && lc_newline &&
                | REGEXP_CONTAINS(station_name, 'Kennington'))) |.

    "Call API method: bigquery.jobs.query
    CALL METHOD lo_bq->query_jobs
      EXPORTING
        iv_p_project_id = lv_project_id
        is_input        = ls_input
      IMPORTING
        es_output       = DATA(ls_response)
        ev_ret_code     = DATA(lv_ret_code)
        ev_err_text     = DATA(lv_err_text)
        es_err_resp     = DATA(ls_err_resp).

    IF lo_bq->is_success( lv_ret_code ).
      "API Call successful, loop through the data & display the result
      IF ls_response-job_complete = abap_true.
        LOOP AT ls_response-rows ASSIGNING FIELD-SYMBOL(<ls_row>).
          LOOP AT <ls_row>-f ASSIGNING FIELD-SYMBOL(<ls_value>).
            ASSIGN <ls_value>-v->* TO FIELD-SYMBOL(<ls_field_value>).
            CASE sy-tabix.
              WHEN 1.
                ls_output-centroid_id = <ls_field_value>.
              WHEN 2.
                ls_output-station_name = <ls_field_value>.
              WHEN 3.
                ls_output-isweekday = <ls_field_value>.
              WHEN 4.
                ls_output-num_trips = <ls_field_value>.
              WHEN 5.
                ls_output-distance_from_city = <ls_field_value>.
            ENDCASE.
          ENDLOOP.
          APPEND ls_output TO lt_output.
          CLEAR ls_output.
        ENDLOOP.
        IF lt_output IS NOT INITIAL.
          cl_demo_output=>new( )->begin_section( 'ML.Predict Query Details'
                               )->write_text( ls_input-query
                               )->write_text( 'Dataset: bigquery-public-data.london_bicycles'
                               )->end_section(
                               )->begin_section( 'ML.Predict Query Results'
                               )->write_data( lt_output
                               )->end_section(
                               )->display( ).
        ENDIF.
      ENDIF.
    ELSE.
      "Display error message in case the API call fails
      MESSAGE lv_err_text TYPE 'E'.
    ENDIF.

    "Close HTTP Connection
    lo_bq->close( ).

  CATCH /goog/cx_sdk INTO DATA(lo_exception).
    MESSAGE lo_exception->get_text( ) TYPE 'E'.
ENDTRY.

5. Salve e ative o relatório.
6. Execute o relatório (F8).

Se a execução for bem-sucedida, você vai ver uma saída de relatório, conforme mostrado abaixo:

8. Parabéns

Parabéns por concluir o codelab "Receber previsões de um modelo de machine learning (ML) do BigQuery usando o SDK ABAP para o Google Cloud".

Você extraiu as previsões de um modelo de machine learning do BigQuery diretamente do seu sistema SAP. Você desbloqueou um novo nível de integração entre ABAP e os serviços do Google Cloud. Amplie seus horizontes com outros codelabs interessantes do SDK ABAP for Google Cloud:

• Como usar a API Translation com o ABAP SDK for Google Cloud
• Fazer upload de um objeto grande para um bucket do Cloud Storage usando a divisão em partes
• Como recuperar credenciais/segredos do Secret Manager com o SDK ABAP for Google Cloud
• Chamar o test-bison da Vertex AI no ABAP

9. Limpar

Se você não quiser continuar com os outros codelabs relacionados ao SDK ABAP para Google Cloud, prossiga com a limpeza.

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar várias arquiteturas, tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda limites da cota.

• Exclua o projeto do Google Cloud:

gcloud projects delete abap-sdk-poc

Excluir recursos individuais

1. Exclua a instância de computação:

gcloud compute instances delete abap-trial-docker

2. Exclua as regras de firewall:

gcloud compute firewall-rules delete sapmachine

3. Exclua a conta de serviço:

gcloud iam service-accounts delete \
    [e-mail]