DataWorks:Desenvolvimento avançado de notebooks

Referencie recursos do projeto (arquivos .py)

Para tornar seu código mais modular, reutilizável e fácil de manter, agrupe funções ou classes comuns em arquivos .py independentes. Em seguida, referencie esses arquivos como recursos do MaxCompute usando a sintaxe ##@resource_reference{"custom_name.py"}.

1. Crie e publique um recurso Python

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

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

   3. Na seção Document Content, clique em Online Editing, cole o código da sua função utilitária no editor de código 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 para publicar o recurso. Isso torna o recurso disponível para tarefas nos ambientes de desenvolvimento e produção.

2. Referencie o recurso em um notebook

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

   ##@resource_reference{"my_utils.py"}
   # If the resource is in a subdirectory, such as my_folder/my_utils.py, reference it by filename only, without the directory path: ##@resource_reference{"my_utils.py"}
   from my_utils import greet
   
   message = greet('DataWorks')
   print(message)

3. Depure no ambiente de desenvolvimento

   Execute a célula Python. A saída será:

   Hello, DataWorks from resource file!

   Importante

   Durante a depuração no ambiente de desenvolvimento, o sistema detecta a declaração ##@resource_reference e baixe automaticamente o arquivo correspondente do Resource Management para o caminho workspace/_dataworks/resource_references no seu diretório pessoal, tornando-o acessível ao seu código.

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

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

   Após clique em Save e Publish no nó de notebook, acesse Operation and Maintenance Center > Auto Triggered Task e clique em Test para executar a tarefa. Após a conclusã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 ..., verifique se você publicou o recurso Python no ambiente de produção.

Para mais informações, consulte Recursos e funções do MaxCompute .

Leia e grave datasets (OSS/NAS)

Durante a execução das tarefas do notebook, leia e grave facilmente em arquivos de grande escala armazenados no OSS ou NAS.

Para mais informações, consulte Uso de datasets em um ambiente de desenvolvimento pessoal .

Use parâmetros do workspace

O DataWorks fornece parâmetros de workspace, que estendem os parâmetros de agendamento existentes. Esses parâmetros permitem a reutilização de configurações globais e o isolamento de ambiente entre tarefas e nós. Referencie um parâmetro do workspace em uma célula SQL ou Python usando o formato ${workspace.param}, onde param é o nome do seu parâmetro de workspace.

1. Crie um parâmetro de workspace: Antes de começar, acesse Operation and Maintenance Center > Scheduling Settings > Workspace Parameters no DataWorks para crie os parâmetros necessários.

2. Referencie um parâmetro de workspace:

   • Referencie um parâmetro de workspace em uma célula SQL.

     SELECT '${workspace.param}';

     Ao executar a célula, o valor resolvido do parâmetro de workspace é impresso.

   • Referencie um parâmetro de workspace em uma célula Python.

     print('${workspace.param}')

     Ao executar a célula, o valor resolvido do parâmetro de workspace é impresso.

   Para mais detalhes, consulte Uso de parâmetros de workspace .

Conecte-se ao MaxCompute

• %odps: Obtenha um objeto de entrada PyODPS

  Este comando retorna um objeto PyODPS autenticado e vinculado ao projeto atual do MaxCompute. Recomendamos este método para interagir com o MaxCompute porque evita a codificação fixa de AccessKeys no seu código.

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

     o=%odps 

  2. Use o recurso de computação do MaxCompute recuperado 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

  Este comando cria uma sessão MaxFrame, que fornece capacidades de processamento de dados distribuído semelhantes ao pandas para o MaxCompute.

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

Conecte-se a recursos de computação Spark

O DataWorks Notebook suporta conexões com múltiplos motores Spark. Esses motores diferem no método de conexão, contexto de execução e gerenciamento de recursos.

Conecte-se ao Lindorm Ray

O grupo de recursos RAY do motor de computação Lindorm fornece serviços de computação distribuída e suporta cargas de trabalho de IA ponta a ponta. Use um comando mágico para se conectar perfeitamente aos recursos do Lindorm Ray em um notebook para desenvolvimento e depuração interativos e, em seguida, publique o notebook como uma tarefa de produção agendada.

1. Estabeleça uma conexão: Execute o comando %lindorm_ray em uma célula Python. Um seletor de recursos de computação aparece no canto inferior direito da célula. Selecione seu recurso de computação do Lindorm e o grupo de recursos RAY criado.

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

   Importante

   • Após conectar-se a um recurso de computação do Lindorm Ray, você não pode mais executar células SQL no mesmo notebook. O motor Lindorm Ray executa exclusivamente código Python e Ray.

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

2. Execute código Ray: Após estabelecer a conexão, 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, o que facilita a depuração interativa.

   O exemplo a seguir define uma tarefa remota simples (usando o decorador @ray.remote) que executa em um cluster Ray e retorna os logs e o resultado final 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: Se precisar especifique configurações adicionais para o ambiente Ray, como instale pacotes Python de terceiros ou carregar arquivos de código locais, use o comando %%lindorm_ray para estabelecer a conexão.

   • Exemplo 1: Instalar dependências

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

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

     Assim que o ambiente estiver pronto, importe e use o pacote nos jobs Ray subsequentes. O exemplo a seguir mostra como chamar jieba em uma função remota para realizar 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: Carregar e usar recursos do DataWorks

     O parâmetro working_dir serve para carregar recursos do Resource Management do DataWorks para um cluster Ray para que possam ser importados e chamados nas tarefas.

     Importante

     • Ao usar working_dir para carregar recursos, os arquivos são carregados diretamente do seu ambiente de desenvolvimento para o cluster Ray e estão sujeitos a um limite de tamanho de 100 MB. Se um pacote de recursos for muito grande, o upload pode falhar ou os nós Ray podem ficar instáveis.

     • Para arquivos grandes ou dependências (>100 MB), carregue-os no OSS e acesse-os pelo seu código, ou empacote-os em uma imagem personalizada. Essa abordagem oferece melhor estabilidade e desempenho.

     # Reference a resource uploaded in DataStudio Resource Management and declare its path.
     %%lindorm_ray
     {
         "runtime_env": {
             "working_dir": "/mnt/workspace/_dataworks/resource_references"
         }
     }

     Suponha que você carregue um arquivo ray_resource.py no Resource Management do DataStudio. Ao escrever e executar a seguinte célula, o sistema analisa automaticamente a declaração ##@resource_reference no código subsequente e baixe o recurso correspondente para o caminho /mnt/workspace/_dataworks/resource_references.

     Código de exemplo para ray_resource.py:

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

     Importante

     Em um ambiente de desenvolvimento, após executar a célula que contém ##@resource_reference, execute novamente a célula %%lindorm_ray acima para carregar os recursos baixados no working_dir para o cluster Ray. Em um ambiente de produção, não é necessário executar novamente.

     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 a depuração, salve e publique o nó de notebook. Ele será então 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: No ambiente de produção, para evitar que logs excessivos afetem o desempenho, o sistema carrega apenas o primeiro 1 MB de logs por padrão. Se os logs forem truncados, a saída inclui um link que direciona você ao console do Lindorm para visualize os logs completos da tarefa.

   • 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 não ocupa mais recursos. Durante o desenvolvimento interativo, encerre a tarefa Lindorm Ray reiniciando o kernel ou fechando o notebook.

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