DataWorks:Desenvolvimento avançado de notebooks

Referencie resources do projeto (arquivos .py)

Encapsule funções ou classes comuns em arquivos .py e referencie-os como resources do MaxCompute usando ##@resource_reference{"custom_name.py"}.

1. Crie e publique um resource Python

   1. No painel de navegação à esquerda do DataStudio do DataWorks, clique em para acessar o Resource Management.

   2. Na árvore do Resource Management, clique com o botão direito no diretório desejado ou clique em + no canto superior direito. Selecione New Resource > MaxCompute Python e nomeie o resource como my_utils.py.

   3. Na seção Document Content, clique em Online Editing, cole o código da função utilitária depurada no editor e clique em Save.

      # my_utils.py
      def greet(name):
          return f"Hello, {name} from resource file!"

   4. Na barra de ferramentas, clique em Save e depois em Publish. Isso torna o resource visível tanto para tarefas de desenvolvimento quanto de produção.

2. Referencie o resource em um notebook

   Na primeira linha de uma célula Python no seu notebook, use a sintaxe ##@resource_reference para referenciar o resource publicado.

   ##@resource_reference{"my_utils.py"}
   # If the resource is in a directory, such as my_folder/my_utils.py, you still use ##@resource_reference{"my_utils.py"} without the directory name.
   from my_utils import greet
   message = greet('DataWorks')
   print(message)

3. Depure e execute no ambiente de desenvolvimento

   Execute a célula Python. O seguinte resultado será impresso:

   Hello, DataWorks from resource file!

   Importante

   Ao depurar e executar no ambiente de desenvolvimento, o sistema detecta a declaração ##@resource_reference e baixa o arquivo alvo do Resource Management para workspace/_dataworks/resource_references no seu diretório pessoal.

   Se ocorrer um erro ModuleNotFoundError, clique em Restart na barra de ferramentas do editor para recarregar o resource e tente novamente.

4. Publique no ambiente de produção e verifique

   Após Save e Publish deste nó de Notebook, acesse Operation and Maintenance Center > Auto Triggered Task e clique em Test para executá-lo. Após a execução bem-sucedida da tarefa, a saída Hello, DataWorks from resource file! aparecerá nos logs.

   Importante

   Se ocorrer um erro There is no file with id ..., certifique-se de ter publicado o resource Python no ambiente de produção primeiro.

Para mais operações, consulte MaxCompute resources and functions .

Leia e grave datasets (OSS/NAS)

Leia e grave arquivos grandes armazenados no OSS ou NAS durante a execução de tarefas do notebook.

Para mais operações, consulte Use datasets in a personal development environment .

Referencie parâmetros de workspace

Além de scheduling parameters, o DataWorks oferece Parâmetros de Workspace para reutilizar configurações globais e isolar ambientes entre tarefas e nós. Referencie-os em células SQL e Python usando ${workspace.param}, onde param é o nome do parâmetro.

1. Crie Parâmetros de Workspace: No DataWorks, acesse Operation and Maintenance Center > Scheduling Settings > Workspace Parameters para criar os parâmetros.

2. Referencie Parâmetros de Workspace:

   • Referencie um Parâmetro de Workspace em uma célula SQL.

     SELECT '${workspace.param}';

     Quando a consulta for executada com sucesso, ela imprimirá o valor resolvido do parâmetro.

   • Referencie um Parâmetro de Workspace em uma célula Python.

     print('${workspace.param}')

     Quando o código for executado com sucesso, ele imprimirá o valor resolvido do parâmetro.

   Para mais detalhes, consulte Use workspace parameters .

Conexão com o MaxCompute

• %odps: Obtenha um objeto de entrada PyODPS

  Não requer AccessKey codificado.

  1. Use um comando mágico para criar uma conexão com o MaxCompute. Insira %odps. Um seletor de recursos de computação do MaxCompute aparece no canto inferior direito e seleciona automaticamente um recurso de computação. Clique em nome do projeto MaxCompute no canto inferior direito para alternar entre projetos do MaxCompute.

     o=%odps 

  2. Use o recurso de computação do MaxCompute retornado para executar um script PyODPS.

     Por exemplo, para obter todas as tabelas no projeto atual:

     with o.execute_sql('show tables').open_reader() as reader:
         print(reader.raw)

• %maxframe: Estabeleça uma conexão MaxFrame

  Cria uma sessão MaxFrame para processamento distribuído de dados semelhante ao pandas no MaxCompute.

  # Connect to and access the MaxCompute MaxFrame session.
  mf_session = %maxframe
  df = mf_session.read_odps_table('your_mc_table')
  print(df.head())
  # After development and debugging, destroy the session to release resources.
  mf_session.destroy()

Conexão com recursos de computação Spark

O DataWorks Notebook suporta múltiplas engines Spark, cada uma com métodos de conexão, contextos de execução e ciclos de vida de recursos diferentes.

Conexão com um recurso de computação Lindorm Ray

O grupo de recursos Ray da engine de computação Lindorm fornece computação distribuída para workloads de IA de ponta a ponta. Use-o para desenvolvimento interativo em notebooks e, em seguida, publique como uma tarefa de produção agendada.

1. Estabeleça uma conexão: Execute o comando mágico %lindorm_ray em uma célula Python. Após executar o comando, um seletor de recursos de computação aparece no canto inferior direito da célula. Selecione seu recurso de computação Lindorm e o grupo de recursos Ray criado.

   # Connect to the specified Lindorm Ray resource group.
   %lindorm_ray

   Importante

   • Após se conectar a um recurso de computação Lindorm Ray, não é mais possível executar células SQL no mesmo notebook. A engine Lindorm Ray foca na execução de código Python e Ray.

   • Se a mesma célula de código for executada várias vezes, o sistema encerra automaticamente o job Ray anterior e inicia um novo. Isso evita desperdício de recursos e conflitos de tarefas.

2. Execute código Ray: Após uma conexão bem-sucedida, escreva e execute código Ray diretamente em uma nova célula Python. Os logs são transmitidos para a área de saída da célula em tempo real para depuração interativa.

   O exemplo a seguir define uma tarefa remota simples usando o decorador @ray.remote. A tarefa é executada no cluster Ray, e os logs e o resultado final são retornados para a área de saída da célula.

   import ray
   import time
   @ray.remote
   def hello_world():
     print("Hello from Lindorm Ray!")
     time.sleep(5)
     return "Task finished."
   # Submit the remote task.
   result_ref = hello_world.remote()
   print(ray.get(result_ref))

3. (Opcional) Especifique parâmetros de inicialização personalizados: Para definir configurações adicionais para o ambiente Ray, como instalar pacotes Python de terceiros ou enviar arquivos de código locais, use %%lindorm_ray para estabelecer a conexão.

   • Exemplo 1: Instalar dependências

     Use o parâmetro pip para instalar o pacote jieba no ambiente Ray.

     %%lindorm_ray
     {
       "runtime_env": {
         "pip": ["jieba"]
       }
     }

     Após o ambiente estar pronto, importe e use o pacote nas tarefas Ray subsequentes. O exemplo a seguir mostra como chamar jieba em uma função remota para segmentação de palavras em chinês:

     import ray 
     @ray.remote
     def do_work(x):
         import jieba
         return "/".join(jieba.cut(x))
     print(ray.get(do_work.remote("Welcome to the DataWorks LindormRay solution")))

   • Exemplo 2: Enviar e usar resources do DataWorks

     Use o parâmetro working_dir para enviar resources do Resource Management para o cluster Ray para importação em suas tarefas.

     Importante

     • Ao usar working_dir para enviar resources, os arquivos são enviados diretamente do seu ambiente de desenvolvimento para o cluster Ray. Aplica-se um limite de tamanho de 100 MB. Se o pacote de resources for muito grande, o envio pode falhar ou o nó Ray pode ficar instável.

     • Para resources ou dependências grandes (acima de 100 MB), envie-os para o OSS e baixe do OSS no seu código, ou empacote-os em uma imagem personalizada para melhor estabilidade e desempenho.

     # Reference and declare the path for a resource from Resource Management.
     %%lindorm_ray
     {
         "runtime_env": {
             "working_dir": "/mnt/workspace/_dataworks/resource_references"
         }
     }

     Suponha que você tenha enviado um arquivo chamado ray_resource.py para o Resource Management no DataWorks. Ao executar a seguinte célula, o sistema analisa a declaração ##@resource_reference e baixa o resource correspondente para /mnt/workspace/_dataworks/resource_references.

     Código de exemplo em ray_resource.py:

     def fun():
         print("This is a test function in ray_resource.py")

     Importante

     No ambiente de desenvolvimento, após executar a célula que contém ##@resource_reference, execute novamente a célula %%lindorm_ray anterior. Executar novamente esta célula inclui os resources baixados no working_dir e os envia para o cluster Ray. Não é necessário executar novamente a célula no ambiente de produção.

     import ray 
     ##@resource_reference{"ray_resource.py"}
     @ray.remote
     def do_work(x):
         print('Ray says:', x)
         from ray_resource import fun
         fun()
         return x
     worker = do_work.remote("Welcome to the DataWorks LindormRay solution")
     print(ray.get(worker))

4. Agendamento e O&M de produção: Após o desenvolvimento e depuração, salve e publique este nó de notebook. Ele será agendado periodicamente como um nó Lindorm Ray em um DAG.

   • Parametrização: Seu código pode usar parâmetros de agendamento padrão do DataWorks, como ${bizdate}.

   • Visualização de logs: Em produção, o sistema carrega apenas o primeiro 1 MB de logs por padrão para evitar problemas de desempenho. Se os logs forem truncados, a saída fornece um link para visualizar os logs completos da tarefa no console Lindorm.

   • Liberação de recursos: Após o término de uma tarefa de produção agendada, a tarefa Lindorm Ray entra em um estado terminal e libera recursos. Durante o desenvolvimento interativo, encerre a tarefa reiniciando o kernel ou fechando o notebook.

Apêndice: Referência rápida de comandos mágicos