Instalar e executar uma anotação do Jupyter em um cluster do Cloud Dataproc

Antes de começar

Caso ainda não tenha feito isso, crie um projeto do Google Cloud Platform e um intervalo do Cloud Storage.

Configurar o projeto

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Ativar Cloud Dataproc e Compute Engine APIs.

    Ativar as APIs

  5. Instale e inicialize o SDK do Cloud.

Criar um intervalo do Cloud Storage no projeto

  1. No Console do GCP, acesse a página Navegador do Cloud Storage.

    Acessar a página "Navegador do Cloud Storage"

  2. Clique em Criar intervalo.
  3. Na caixa de diálogo Criar intervalo, especifique os seguintes atributos:
  4. Clique em Criar.
  5. As anotações serão armazenadas no Cloud Storage em gs://bucket-name/notebooks/.

Visão geral

Este tutorial demonstra a criação de um cluster do Cloud Dataproc com um script de inicialização shell bash que instala e executa uma anotação do Jupyter no cluster. O script está no Cloud Storage em gs://dataproc-initialization-actions/jupyter/jupyter.sh e colocalizado com outros scripts de inicialização no repositório GoogleCloudPlatform/dataproc-initialization-actions.

Depois de criar o cluster com um script de inicialização que instala a anotação do Jupyter no cluster, este tutorial mostrará como se conectar à anotação usando o navegador local.

#!/bin/bash

#

set -exo pipefail

readonly ROLE="$(/usr/share/google/get_metadata_value attributes/dataproc-role)"
readonly INIT_ACTIONS_REPO="$(/usr/share/google/get_metadata_value attributes/INIT_ACTIONS_REPO \
  || echo 'https://github.com/GoogleCloudPlatform/dataproc-initialization-actions.git')"
readonly INIT_ACTIONS_BRANCH="$(/usr/share/google/get_metadata_value attributes/INIT_ACTIONS_BRANCH \
  || echo 'master')"

readonly JUPYTER_CONDA_CHANNELS="$(/usr/share/google/get_metadata_value attributes/JUPYTER_CONDA_CHANNELS)"

readonly JUPYTER_CONDA_PACKAGES="$(/usr/share/google/get_metadata_value attributes/JUPYTER_CONDA_PACKAGES)"

echo "Cloning fresh dataproc-initialization-actions from repo ${INIT_ACTIONS_REPO} and branch ${INIT_ACTIONS_BRANCH}..."
git clone -b "${INIT_ACTIONS_BRANCH}" --single-branch "${INIT_ACTIONS_REPO}"

./dataproc-initialization-actions/conda/bootstrap-conda.sh

source /etc/profile.d/conda.sh

PYTHON="$(ls /opt/conda/bin/python || which python)"
PYTHON_VERSION="$(${PYTHON} --version 2>&1 | cut -d ' ' -f 2)"
conda install jupyter matplotlib "python==${PYTHON_VERSION}"

conda install 'testpath<0.4'

if [ -n "${JUPYTER_CONDA_CHANNELS}" ]; then
  echo "Adding custom conda channels '${JUPYTER_CONDA_CHANNELS//:/ }'"
  declare -a a_channels=();
  a_channels=${JUPYTER_CONDA_CHANNELS//:/ };

  for channel in ${a_channels[@]};
  do
    conda config --add channels ${channel}
  done
fi

if [ -n "${JUPYTER_CONDA_PACKAGES}" ]; then
  echo "Installing custom conda packages '${JUPYTER_CONDA_PACKAGES/:/ }'"
  conda install ${JUPYTER_CONDA_PACKAGES//:/ }
fi

pip install jgscm==0.1.7

if [[ "${ROLE}" == 'Master' ]]; then
  ./dataproc-initialization-actions/jupyter/internal/setup-jupyter-kernel.sh
  ./dataproc-initialization-actions/jupyter/internal/launch-jupyter-kernel.sh
fi
echo "Completed installing Jupyter!"

if [[ ! -v "${INSTALL_JUPYTER_EXT}" ]]; then
  INSTALL_JUPYTER_EXT=false
fi
if [[ "${INSTALL_JUPYTER_EXT}" = true ]]; then
  echo "Installing Jupyter Notebook extensions..."
  ./dataproc-initialization-actions/jupyter/internal/bootstrap-jupyter-ext.sh
  echo "Jupyter Notebook extensions installed!"
fi

Criar um cluster e instalar uma anotação do Jupyter

Comando gcloud

  1. Execute o comando gcloud dataproc clusters create a seguir localmente em uma janela do terminal ou no Cloud Shell (o Cloud Shell executa Linux) para criar o cluster e instalar a anotação do Jupyter no nó mestre do cluster. Insira os valores nos marcadores cluster-name, project-id e bucket-name. Em bucket-name, especifique o nome do intervalo criado em Criar um intervalo do Cloud Storage no projeto. Especifique apenas o nome do intervalo. As anotações serão armazenadas no Cloud Storage em gs://bucket-name/notebooks/. A sinalização --initialization-actions especifica o local no Cloud Storage onde o script de inicialização está. Consulte Ações de inicialização para ver mais informações.

    Linux/MacOS

    gcloud dataproc clusters create cluster-name \
        --project project-id \
        --bucket bucket-name \
        --initialization-actions \
            gs://dataproc-initialization-actions/jupyter/jupyter.sh
    

    Windows

    gcloud dataproc clusters create cluster-name ^
        --project project-id ^
        --bucket bucket-name ^
        --initialization-actions ^
            gs://dataproc-initialization-actions/jupyter/jupyter.sh
    

Console

  1. Acesse a página Clusters do Cloud Dataproc no console do GCP.
  2. Clique em Criar cluster para abrir a página "Criar um cluster".
  3. Digite o nome do cluster no campo Nome.
  4. Selecione uma região e uma zona para o cluster nos menus suspensos Região e Zona. Consulte Regiões e zonas disponíveis. O padrão é a região global, que é um namespace especial de várias regiões capaz de implantar instâncias em todas as zonas do Compute Engine globalmente. Também é possível especificar uma região distinta e selecionar "Sem preferência" para a zona a fim de permitir que o Cloud Dataproc escolha uma zona dentro da região selecionada para o cluster. Consulte Colocação em zona automática do Cloud Dataproc.
  5. Expanda o painel Opções avançadas.

  6. Digite o nome do intervalo criado em Criar um Cloud Storage no projeto, no campo Intervalo de preparo do Cloud Storage. Só especifique o nome do intervalo. As anotações serão armazenadas no Cloud Storage em gs://bucket-name/notebooks/.
  7. Digite gs://dataproc-initialization-actions/jupyter/jupyter.sh no campo Ações de inicialização. Este script, que configura e executa uma anotação do Jupyter na instância mestre do cluster, será executado logo depois do novo cluster ser criado.

    Copie e cole o URI do bloco de código abaixo.
    gs://dataproc-initialization-actions/jupyter/jupyter.sh
    
  8. Use os padrões fornecidos para todas as outras opções.

  9. Clique em Criar para criar o cluster e instalar a anotação do Jupyter no nó mestre do cluster.

Abrir a anotação do Jupyter no navegador

Depois que o cluster estiver em execução, siga as etapas abaixo para abrir a anotação do Jupyter no navegador.

  1. Crie um túnel SSH. Atualmente, como o Jupyter usa as mensagens do protocolo WebSocket, que não é compatível com o Cloud Shell, não use o Cloud Shell com o encaminhamento de portas local para criar o túnel SSH. Em vez disso, use um proxy SOCKS com encaminhamento de portas dinâmico para criar o túnel SSH.

  2. Configure o navegador.

  3. Conecte-se à interface da anotação. Como você usou um proxy SOCKS com encaminhamento de portas dinâmico para criar um túnel SSH, digite o seguinte URL no navegador para se conectar à anotação: http://cluster-name-m:8123.

A página de abertura da anotação do Jupyter é exibida no navegador local.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Cloud Dataproc
Precisa de ajuda? Acesse nossa página de suporte.