Como criar um farm de renderização no GCP usando o OpenCue

Festa da dança do robô

Neste tutorial, mostramos como implantar o sistema de gerenciamento de renderização do OpenCue em máquinas virtuais (VMs) do Linux usando o Google Cloud. Para concluir todo o tutorial, são necessárias de três a quatro horas.

As ferramentas de gerenciamento de renderização são usadas em efeitos visuais e produção de animação para dividir jobs complexos em tarefas individuais e espalhar esses processos em um amplo intervalo de recursos de computação. Essas ferramentas são usadas para gerenciar jobs, como renderizações 3D, composições 2D, transcodificação de dados de um formato em outro e verificação de recursos dentro e fora de bancos de dados. As ferramentas costumam ser usadas para vincular estágios e dependências de jobs. Em instalações maiores, um sistema de gerenciamento de renderizações pode aceitar milhares de jobs simultâneos e fornece a interface a fim de alocar recursos para cada estágio de um job, gerenciando registros, ferramentas de solução de problemas e recursos.

O Google colaborou com a Sony Pictures Imageworks para lançar o OpenCue, um sistema de gerenciamento de renderizações de código aberto de produção comprovada que funciona no Linux e no MacOS. O OpenCue foi usado para criar farms de renderizações no local e para implantações híbridas em grande escala, utilizando recursos de vários fornecedores de nuvem.

Este tutorial é destinado a administradores de TI e diretores técnicos de pipeline familiarizados com as ferramentas e os conceitos a seguir. Não se preocupe se você não for especialista em tudo nesta lista. Indicaremos mais recursos quando aplicável.

  • Princípios operacionais do gerenciamento de renderizações distribuído
  • Git e GitHub
  • Docker para criar e executar contêineres
  • Scripts em lotes para edição de scripts e execução de recursos
  • Configuração do Python e edição de scripts
  • Ferramentas e conceitos básicos de gerenciamento de recursos do Google Cloud, incluindo Cloud SQL, Compute Engine, Cloud Storage e Container Registry

Como as ferramentas de gerenciamento de renderizações abrangem vários casos de uso e orquestram uma ampla variedade de recursos, há muitas maneiras de configurar um farm de renderizações. Neste tutorial, nos concentramos em uma configuração e colocamos o OpenCue ativo e em funcionamento o mais rapidamente possível. A criação de uma arquitetura mais otimizada para seu farm de renderização pode exigir a modificação de etapas, a definição do perfil de desempenho do fluxo de trabalho ou a troca de tipos de recursos do Google Cloud. Para mais informações sobre as opções de configuração e gerenciamento de um farm de renderização no Google Cloud, consulte Como criar um farm de renderização híbrida. E para mais informações sobre como proteger os dados, consulte Como proteger cargas de trabalho de renderização.

Objetivos

  • Instalar e configurar módulos do OpenCue usando o Docker e o Python.
  • Criar um banco de dados do OpenCue e preenchê-lo com dados de esquema e exemplo.
  • Criar recursos do Cloud Storage e preenchê-los com os arquivos de cenas de animação do tutorial.
  • Configurar e criar imagens do Docker localmente, armazená-las no Container Registry e iniciar os recursos do Compute Engine usando contêineres.
  • Criar modelos de instâncias e grupos de instâncias gerenciados para permitir o escalonamento eficiente dos recursos de computação.
  • Configurar uma estação de trabalho para executar a interface do OpenCue no local.
  • Renderizar uma sequência de animação e explorar o gerenciamento de jobs usando a interface do OpenCue.

Custos

Use a calculadora de preços para gerar uma estimativa de custo com base no uso projetado.

Este tutorial abrange todos os passos da criação de um farm de renderizações funcional usando restrições máximas quanto ao número de máquinas e ao dimensionamento. Para atender às diretrizes de preços do nível gratuito do Google Cloud, neste tutorial, você renderiza uma animação com baixa resolução e taxas de amostragem em algumas VMs com duas vCPUs.

O custo dos recursos que compõem este tutorial, se usados por um total de quatro horas, será de US$ 3,27.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative as APIs Container Registry and Compute Engine.

    Ative as APIs

  5. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  6. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  7. Ative as APIs Container Registry and Compute Engine.

    Ative as APIs

  8. Verifique se você tem os seguintes recursos instalados na máquina local:
    • Docker Este tutorial é testado com o Docker Engine versão 18.09.0.
    • Python Este tutorial é testado com a versão 2.7.10.
    • Pip Este tutorial é testado com a versão 19.0.
    • Virtualenv Este tutorial é testado com a versão 16.2.0.
    • gcsfuse Este tutorial é testado com a versão 0.23.0.
    • A versão mais recente do SDK do Cloud. Neste tutorial, é necessário instalar o SDK do Cloud para usar as ferramentas de linha de comando gcloud e gsutil. Você executa as ferramentas gcloud e gsutil em um terminal na estação de trabalho local.

Visão geral do OpenCue

A interface do OpenCue usa vários módulos e comandos, além de vários conceitos e termos exclusivos. As ferramentas e as técnicas a seguir são usadas na implantação de um farm de renderizações híbrido básico. Para informações sobre tópicos mais avançados e opções de implantação diferentes, consulte a documentação do OpenCue.

  • Cuebot: a ferramenta de programação do OpenCue. O Cuebot processa a distribuição de jobs, gerencia recursos de renderização e se comunica com o banco de dados. O Cuebot pode ser acessado usando Python e Bash por meio de uma interface de linha de comando (CLI), mas uma interface visual também está incluída como um módulo separado e será descrita posteriormente. Neste exemplo, você executa o Cuebot em uma VM do Google Cloud. Também é possível executá-lo localmente para implantações locais. Em implantações maiores ou híbridas, é possível usar várias instâncias do Cuebot para alta disponibilidade.
  • Banco de dados: o Cuebot interage com um servidor de banco de dados PostgreSQL para armazenar o estado do aplicativo. Mesmo em uma implantação com vários Cuebots, somente um banco de dados é compartilhado entre as instâncias. Neste tutorial, usamos uma instância do Cloud SQL para facilitar a implantação.
  • CueGUI (em inglês): a interface visual para interagir com o Cuebot. O CueGUI é usado para monitorar e gerenciar configurações de jobs e renderizar hosts. Neste tutorial, você executa o Cuebot na nuvem e o CueGUI na máquina local.
  • Renderizar hosts: recursos de renderização individuais usados para processar tarefas individuais. Esses hosts podem estar no local, na nuvem ou em uma combinação de ambos. Neste tutorial, você usará um grupo de instâncias gerenciadas de VMs no Google Cloud como hosts de renderização.
  • RQD: Render Queue Daemon executado em hosts de renderização individuais e que interage com o Cuebot para enviar e receber instruções sobre comandos que precisam ser executados.
  • CueSubmit: GUI para configurar e iniciar jobs. Execute este programa em Python como uma GUI autônoma ou como um plug-in em um software de terceiros. O OpenCue inclui um plug-in do Maya (testado com a versão 2017 e posteriores) e o Nuke (testado com a versão 11). O repositório do OpenCue (em inglês) inclui um código que é possível modificar para criar os próprios plug-ins para outras ferramentas de terceiros ou para personalizar o pipeline.
  • PyCue: uma coleção de bibliotecas do Python usada para interagir com o Cuebot. Use essas bibliotecas para criar mais ferramentas ou se comunicar com o Cuebot na linha de comando, em vez de usar uma GUI.
  • PyOutline: biblioteca do Python para criar envios de jobs do OpenCue. O PyOutline possibilita a criação de uma especificação de job e a definição de dependências. Neste tutorial, você não interage diretamente com esse módulo, porque ele é chamado em segundo plano pelo CueSubmit.
  • CueAdmin: uma ferramenta de linha de comando que usa a API PyCue Python para administrar o OpenCue.

Arquitetura do programa OpenCue

O diagrama da arquitetura a seguir ilustra como os módulos do OpenCue se conectam e se comunicam.

Diagrama da arquitetura do OpenCue

Recursos do Google Cloud usados neste tutorial

O diagrama de arquitetura a seguir ilustra os recursos do Google Cloud necessários para concluir este tutorial.

Recursos do Google Cloud necessários para concluir este tutorial

Como fazer o download do repositório do OpenCue

O repositório oficial do OpenCue está hospedado no GitHub.

  • Navegue até o espaço de trabalho e o diretório que você usará neste tutorial e faça o download do repositório do OpenCue:

    cd ~/
    git clone --branch 0.3.6 https://github.com/AcademySoftwareFoundation/OpenCue
    

Como criar um bucket do Cloud Storage e preenchê-lo com arquivos do tutorial

Neste tutorial, usamos um bucket do Cloud Storage para armazenar todos os arquivos de cenas de animação e outras dependências de arquivos de entrada, bem como arquivos de registro de saída renderizada final e hospedagem de renderizações.

Em uma etapa posterior, você vai instalar e usar o Cloud Storage FUSE (gcsfuse). Essa ferramenta é um adaptador FUSE de código aberto que pode ser usado para ativar buckets do Cloud Storage como sistemas de arquivos nos hosts de renderização do Linux e na máquina local. gcsfuse oferece uma opção de armazenamento econômica e eficiente para esse fluxo de trabalho. No entanto, é possível melhorar drasticamente o desempenho de alguns trabalhos, combinando jobs individuais em um perfil de armazenamento otimizado para as necessidades específicas. O Google Cloud tem muitas opções de armazenamento, mas abordar os prós e os contras de cada fluxo de trabalho vai além do escopo deste documento. Para mais informações sobre opções de armazenamento, consulte Como criar um farm de renderização híbrido ou fale com um representante do Google Cloud para adaptar uma opção de armazenamento às suas necessidades.

Criar um bucket do Cloud Storage

Para criar um bucket, verifique se você está no projeto correto:

  • Crie um bucket do Cloud Storage [YOUR_BUCKET_NAME] para armazenar os dados do tutorial.

    gcloud config set project [YOUR_PROJECT_ID]
        gsutil mb -l us-central1 gs://[YOUR_BUCKET_NAME]
    

    O comando gsutil faz referência à criação de recursos na região us-central1.

Sincronizar dados do tutorial com o bucket

O bucket do Cloud Storage contém aproximadamente 950 MB de dados para este tutorial. Use gsutil rsync para sincronizar os dados da origem com um bucket de destino sem precisar fazer o download desses dados na máquina local. Observe a sinalização -r, que copia subdiretórios recursivos, e a sinalização -m, sincronizada em paralelo e útil durante o processamento com vários arquivos.

  1. Crie uma variável de ambiente para o nome do bucket do Cloud Storage:

    export YOUR_BUCKET=[YOUR_BUCKET_NAME]
    
  2. Sincronize os dados do exemplo com o bucket:

    gsutil -m rsync -r gs://cloud-solutions-group-opencue gs://$YOUR_BUCKET
    

Fazer upload do esquema e dos dados do banco de dados de exemplo

Faça upload do esquema do banco de dados e dos dados de demonstração de exemplo para preencher a tabela do banco de dados:

  1. Copie os arquivos V1__Initial_schema.sql, V2__Add_limit_table.sql e V3__increase_show_length.sql do diretório local do OpenCue para o bucket do tutorial do Cloud Storage:

    gsutil cp ~/OpenCue/cuebot/src/main/resources/conf/ddl/postgres/migrations/* gs://$YOUR_BUCKET/database/
    
  2. Copie o arquivo demo_data.sql do diretório local do OpenCue para o bucket do tutorial do Cloud Storage:

    gsutil cp ~/OpenCue/cuebot/src/main/resources/conf/ddl/postgres/demo_data.sql gs://$YOUR_BUCKET/database/
    

Como implantar o banco de dados

O módulo Cuebot do OpenCue armazena dados de estado do programa em um banco de dados do PostgreSQL. Para este tutorial, você primeiro reserva um IP externo para a VM que funciona como Cuebot. Em seguida, você provisiona e configura uma instância do Cloud SQL, configura a conectividade de rede autorizando o endereço IP do Cuebot e, por fim, preenche o banco de dados com um esquema e dados de demonstração.

Reservar um endereço IP externo estático para Cuebot

Antes de criar o banco de dados ou a VM do Cuebot, reserve um IP externo estático para a VM do Cuebot a ser usada na comunicação de rede entre esses dois recursos:

  1. Acesse a página Reservar um endereço estático, no Console do Cloud.

    ACESSAR A PÁGINA "RESERVAR UM ENDEREÇO ESTÁTICO"

  2. Escolha um nome para o novo endereço, por exemplo, cuebotstaticip.

  3. Em Nível de serviço de rede, especifique Premium.

  4. Em Versão IP, especifique IPv4.

  5. Em Tipo, escolha Regional.

  6. Selecione a região us-central1.

  7. Deixe Anexado a definido como Nenhum.

  8. Clique em Reservar para reservar o IP.

Depois que o recurso for criado, você será redirecionado para a página Endereços IP externos. Refira-se a esse endereço como [RESERVED_STATIC_IP_ADDRESS].

Criar uma instância do Cloud SQL

Há muitas opções para criar um banco de dados do PostgreSQL. Neste tutorial, usamos o Cloud SQL, que oferece facilidade de configuração e um banco de dados totalmente gerenciado no Google Cloud. Essa instância usa SSD para leituras e gravações rápidas, mas tem pequena capacidade de armazenamento inicial, apenas 1 vCPU e 3,75 GB de RAM. Ao escalonar o OpenCue para implantações maiores, esse recurso é um dos primeiros que você quer expandir, e o Cloud SQL pode ser escalonado com sua implantação.

  1. Acesse a página "Instâncias" do Cloud SQL no Google Cloud.

    ACESSAR A PÁGINA "INSTÂNCIAS DO CLOUD SQL"

  2. Selecione o projeto e clique em Continuar.

  3. Clique em Criar instância.

  4. Clique em PostgreSQL.

  5. Digite um Código da instância, por exemplo, opencuedatabase.

  6. Digite uma senha para o usuário postgres padrão. Ao criar o Cuebot, você faz referência a essa senha como [DATABASEPASSWORD].

  7. Defina region como us-central1 e zone como us-central1-a.

  8. Configure as opções de conectividade:

    1. Abra Mostrar opções de configuração e selecione Conectividade.
    2. Selecione IP público e +Adicionar rede.
    3. Em Rede, digite [RESERVED_STATIC_IP_ADDRESS].
    4. Clique em Criar.

    Você volta à lista de instâncias. A nova instância fica esmaecida enquanto é iniciada.

Criar um banco de dados do Cloud SQL

  1. Na página Detalhes da instância do recurso do Cloud SQL, selecione Bancos de dados.
  2. Selecione Criar banco de dados.
  3. Defina o nome do banco de dados como cuebot.
  4. Clique em Criar.
  5. Importe o esquema do banco de dados e os dados de demonstração:

    1. Selecione Importar.
    2. Na linha de arquivo do Cloud Storage, clique em Procurar.
    3. Acesse o bucket de armazenamento [YOUR_BUCKET_NAME] enviado e importe o esquema do banco de dados selecionando o seguinte arquivo:

      gs://[YOUR_BUCKET_NAME]/database/V1__Initial_schema.sql
      
    4. Defina o formato de importação para SQL.

    5. Em Banco de dados, selecione cuebot.

    6. Selecione Mostrar opções avançadas.

    7. Em Usuário, selecione o usuário postgres.

    8. Clique em Importar.

    Quando a importação for concluída, você será redirecionado para a página Detalhes da instância do Cloud SQL.

    Repita as etapas anteriores para importar os dados de demonstração dos seguintes arquivos:

    gs://[YOUR_BUCKET_NAME]/database/V2__Add_limit_table.sql
    gs://[YOUR_BUCKET_NAME]/database/V3__increase_show_length.sql
    gs://[YOUR_BUCKET_NAME]/database/demo_data.sql
    

Quando essas importações forem concluídas, você será redirecionado para a página Detalhes da instância do Cloud SQL. Anote o endereço IP do Cloud SQL, mencionado posteriormente como [CLOUD_SQL_IP_ADDRESS], porque você precisará dele ao configurar o Cuebot em um passo subsequente.

Como preparar uma imagem do Docker do Cuebot para implantação

Neste tutorial, o Cuebot é implantado como um contêiner do Docker em uma única VM do Compute Engine. Comece criando uma imagem do Docker do Cuebot localmente no repositório do OpenCue e enviando-a para o Container Registry. O Container Registry é um repositório particular de imagens do Docker no Google Cloud que você usa para armazenar as imagens do Docker neste tutorial. Para mais informações sobre esse fluxo de trabalho, consulte a documentação do Compute Engine.

Criar a imagem

  1. Verifique se você está no nível raiz do repositório do OpenCue:

    cd ~/OpenCue
    
  2. Crie uma variável chamada TAG_NAME e outra PROJECT_NAME e use o Docker para criar uma imagem com essa tag para rastreamento. Ao incluir gcr.io/[PROJECT_NAME] na etapa de versão, você ativa a marcação para sincronização posterior com o Container Registry.

    export TAG_NAME=demo
    export PROJECT_NAME=[PROJECT_NAME]
    docker build -t gcr.io/$PROJECT_NAME/opencue/cuebot:$TAG_NAME -f cuebot/Dockerfile .
    

Sincronizar a imagem com o Container Registry

Autorize a ferramenta gcloud a permitir que o Docker faça o upload de imagens para o Container Registry. Em seguida, sincronize a imagem do Docker do Cuebot com o Container Registry.

  1. Execute o seguinte comando para autorizar a ferramenta gcloud e a sincronização do Docker:

    gcloud auth configure-docker
    
  2. No prompt a seguir, digite y e pressione Enter.

    Do you want to continue (Y/n)?
  3. Envie a imagem do Docker do Cuebot do repositório local para o Container Registry:

    docker push gcr.io/$PROJECT_NAME/opencue/cuebot:$TAG_NAME
    

Esse upload demora um pouco enquanto a sincronização é concluída.

Como configurar e provisionar a VM do Cuebot

Use o console para provisionar uma VM com um SO otimizado para o contêiner, defina as configurações do contêiner, crie uma conexão com o banco de dados e anexe o endereço IP estático externo reservado.

  1. Acesse a página Instâncias de VMs.

    ACESSAR A PÁGINA "INSTÂNCIAS DE VM"

  2. Clique no botão Criar instância para criar uma nova instância.

  3. Nomear sua instância cuebot.

  4. Defina region como us-central1 e zone como us-central1-a.

  5. Em Tipo de máquina, selecione Personalizar e configure um tipo de máquina de uma vCPU e 6,5 GB.

  6. Defina as configurações do contêiner:

    1. Na seção Contêiner, selecione Implantar imagem do contêiner.
    2. Atualize [PROJECT_NAME] e especifique a seguinte Imagem do contêiner.

      gcr.io/[PROJECT_NAME]/opencue/cuebot:demo

    3. Expanda Opções avançadas de contêiner.

    4. Em Argumentos de comando, adicione três argumentos clicando em + Adicionar argumento três vezes.

    5. Digite os argumentos de comando a seguir, substituindo [CLOUD_SQL_IP_ADDRESS] e [DATABASEPASSWORD] pelos valores.

      --datasource.cue-data-source.jdbc-url=jdbc:postgresql://[CLOUD_SQL_IP_ADDRESS]/cuebot
      --datasource.cue-data-source.username=postgres
      --datasource.cue-data-source.password=[DATABASEPASSWORD]
      

      Em que:

      Argumento de comando Explicação e entrada necessárias
      --datasource.cue-data-source.jdbc-url=jdbc:postgresql://[CLOUD_SQL_IP_ADDRESS]/cuebot Permite a comunicação do Cuebot com o banco de dados. A entrada é [CLOUD_SQL_IP_ADDRESS]/[DATABASE_NAME]. Você usou cuebot para o nome do banco de dados em uma etapa anterior. Portanto, ele é inserido aqui.
      --datasource.cue-data-source.username=postgres O Cuebot exige o nome de usuário do banco de dados durante a conexão. Durante a configuração, você usou o nome de usuário padrão, postgres, para que ele seja inserido aqui. Para produção, você precisa seguir as práticas recomendadas de segurança e criar um novo usuário com privilégios específicos.
      --datasource.cue-data-source.password=[DATABASEPASSWORD] O Cuebot exige a senha do banco de dados durante a conexão. Digite [DATABASEPASSWORD] aqui.
  7. Defina as configurações de rede:

    1. Em Rede, selecione Interfaces de rede.
    2. Clique em IP externo e selecione o endereço IP externo reservado criado anteriormente para o Cuebot, cuebotstaticip.
    3. Clique em Concluído.
    4. Não altere os valores padrão das configurações.
    5. Clique em Criar.

Demora um pouco para a VM ser inicializada. Anote o endereço IP interno de que você precisa ao criar o modelo de instância. O endereço será mencionado posteriormente como [CUEBOT_INTERNAL_IP_ADDRESS].

Como criar hosts de renderização

Os hosts de renderização são compostos de VMs em execução como um grupo de instâncias gerenciadas (MIG, na sigla em inglês), que ativa controles de localização e escalonamento dos recursos. O MIG usa um modelo de instância para determinar o tipo de máquina, ativar o gerenciamento de contas de serviço, implantar uma imagem de contêiner e definir configurações de contêiner e variáveis de ambiente.

As imagens do contêiner são usadas para configurar muitas das dependências e pacotes de software necessários para executar as tarefas de renderização do tutorial. Para configurar as imagens do contêiner para o projeto, use o Docker a fim de criar uma imagem do host de renderização base e armazená-la em um repositório local. Em seguida, é possível personalizar essa base adicionando um software específico da tarefa e as configurações do Google Cloud do repositório do tutorial antes de implantá-lo no Container Registry.

Criar a imagem do host de renderização base

  • No shell local, crie a imagem do host de renderização base.

    cd ~/OpenCue
    export TAG_NAME=demo
    docker build -t opencue/rqd:$TAG_NAME -f rqd/Dockerfile .
    

Configurar a imagem do Blender

O Dockerfile e os scripts relacionados necessários para criar a imagem do Blender do host de renderização estão no repositório do tutorial. Nesta seção, você faz o download do repositório e atualiza algumas configurações para que ele funcione com o projeto.

  1. Acesse o diretório e o espaço de trabalho que você está usando neste tutorial e faça o download do repositório do tutorial.

    cd ~
    git clone https://github.com/GoogleCloudPlatform/python-opencue-demo.git
    
  2. Quando o host de renderização é iniciado, o script rqd_startup.sh neste repositório chama gcsfuse para ativar o bucket do tutorial como um sistema de arquivos no caminho /shots. Abra o Dockerfile no editor de texto e atualize a variável GCS_FUSE_BUCKET a fim de apontar para o bucket do tutorial:

    1. Em um shell, copie o arquivo a seguir para a raiz do repositório.

      cp ~/python-opencue-demo/third_party/Dockerfile ~/python-opencue-demo/Dockerfile
      
    2. Em um editor de texto de sua preferência, edite o arquivo:

      ~/python-opencue-demo/Dockerfile
      
    3. Atualize [YOUR_BUCKET_NAME] com o nome do bucket na seguinte linha:

      ENV GCS_FUSE_BUCKET [YOUR_BUCKET_NAME]
      
    4. Salve e feche o editor de texto.

Criar a imagem e enviá-la para o Container Registry

  1. Crie a imagem:

    cd ~/python-opencue-demo
    docker build -t gcr.io/$PROJECT_NAME/opencue/rqd-blender:$TAG_NAME .
    
  2. Quando a criação for concluída, envie a imagem para o Container Registry:

    docker push gcr.io/$PROJECT_NAME/opencue/rqd-blender:$TAG_NAME
    

Como implantar hosts de renderização

Os hosts de renderização precisam ter permissões de leitura e gravação durante a renderização. Para conceder acesso a eles, crie uma conta de serviço usando o princípio da segurança de menor privilégio. Use essa conta na identidade e no acesso à API durante o provisionamento das VMs.

Criar uma conta de serviço

  1. No Console do Cloud, acesse a página Contas de serviço:

    ACESSAR A PÁGINA "CONTAS DE SERVIÇO"

  2. Clique em Selecione um projeto.

  3. Selecione o projeto e clique em Abrir.

  4. Clique em + Criar conta de serviço.

  5. Digite um [SERVICE_ACCOUNT_NAME]. Por exemplo, storageservice e clique em Criar.

  6. Selecione a função Administrador do objeto de armazenamento para a conta de serviço e clique em Continuar.

  7. Clique em Concluído.

Criar um modelo de instância

Usando a imagem rqd-blender do Docker, crie um modelo de instância para determinar o dimensionamento e as configurações da VM:

  1. No Console do Cloud, acesse a página Modelos de instância.

    ACESSAR A PÁGINA "MODELOS DE INSTÂNCIA"

  2. Clique em Criar modelo de instância.

  3. Dê um nome ao modelo da instância, por exemplo, rqd-blender.

  4. Em Tipo de máquina, selecione n1-highmem-2.

  5. Defina as configurações do contêiner:

  6. Na seção Contêiner, marque a caixa de seleção Implantar uma imagem de contêiner nesta instância de VM.

  7. Atualize [PROJECT_NAME] e especifique o seguinte em Imagem do contêiner:

    gcr.io/[PROJECT_NAME]/opencue/rqd-blender:demo
    
  8. Permita o acesso aos dispositivos do sistema para registrar as instâncias do RQD-blender com o Cuebot no horário de início:

    1. Clique em Opções avançadas de contêiner.
    2. Selecione Executar como privilegiado.
    3. Clique em + Adicionar variável em Variável de ambiente e defina NAME como CUEBOT_HOSTNAME e VALUE como [CUEBOT_INTERNAL_IP_ADDRESS], que se refere ao endereço IP interno da VM do Cuebot que você provisionou anteriormente.
  9. Configure a conta de serviço:

    1. Na seção Conta de serviço, selecione o [SERVICE_ACCOUNT_NAME] criado anteriormente.
    2. Não altere as outras configurações padrão.
    3. Clique em Criar.

Criar um grupo de instâncias gerenciadas

Usando o modelo de instância, crie um grupo de instâncias gerenciadas para determinar a localização da VM, o número de instâncias e as configurações de escalonamento automático.

  1. No Console do Cloud, acesse a página Grupos de instâncias.

    ACESSAR A PÁGINA "GRUPOS DE INSTÂNCIAS"

  2. Clique em Criar grupo de instâncias.

  3. Digite um nome para o grupo de instâncias gerenciadas, por exemplo, rqd-blender-mig.

  4. Selecione Zona única e a região us-central1 e a zona us-central1-a.

  5. Em Tipo de grupo, selecione Grupo de instâncias gerenciadas.

  6. Em Modelo de instância, selecione o modelo de instância, por exemplo, rqd-blender.

  7. Defina Escalonamento automático como Desativado.

  8. Em Número de instâncias, especifique 3.

  9. Clique em Criar.

Como configurar a estação de trabalho local

O Cuebot agora está em execução no Google Cloud e pronto para gerenciar os hosts de renderização e a fila de jobs. Para ativar a interface visual para o envio e o gerenciamento de tarefas, configure a estação de trabalho local para executar o CueSubmit e o CueGUI e conecte-se do host local ao Google Cloud.

Criar um diretório e definir permissões para o ponto de ativação do bucket

  • Crie um ponto de ativação para o bucket do Cloud Storage e defina as permissões de leitura e gravação.

    sudo mkdir /shots
    sudo chmod 777 /shots
    sudo chown $USER /shots
    

    Quando montados em sua estação de trabalho local e processam o host, esses caminhos são resolvidos para algo como /shots/robotdanceparty/sh_05/sh_05_lores.blend para o arquivo de cena de animação de entrada.

Ativar o bucket do tutorial

  • Instrua gcsfuse a ativar o bucket do tutorial na máquina local como um sistema de arquivos no caminho /shots. A sinalização --implicit-dirs (em inglês) é usada para guiar o mapeamento de objetos para diretórios.

    gcsfuse --implicit-dirs $YOUR_BUCKET /shots
    

    Configurar encaminhamento SSH

Para proteger a comunicação entre a estação de trabalho local e o Google Cloud, este tutorial usa o encaminhamento de SSH. Os comandos a seguir abrem uma porta para encaminhar chamadas entre as interfaces do OpenCue e do Cuebot.

  1. Abra um novo shell e o reserve para o processo SSH.
  2. Atualize [YOUR_PROJECT_ID] e execute os seguintes comandos:

    export CUEBOT_INSTANCE_NAME=cuebot
    export PROJECTID=[YOUR_PROJECT_ID]
    export ZONE=us-central1-a
    gcloud compute ssh $CUEBOT_INSTANCE_NAME --project $PROJECTID --zone $ZONE -- -N -L 8443:127.0.0.1:8443
    

Inicializar um ambiente virtual

  1. Abra uma nova janela do shell e a reserve para o uso do CueGUI e do CueSubmit.
  2. Para isolar o ambiente antes da instalação, execute virtualenv:

    cd ~/OpenCue
    virtualenv --python python2 venv
    

    Saiba mais sobre virtualenv.

  3. Crie o ambiente virtual e instale as dependências usando pip.

    source venv/bin/activate
    pip install -r requirements.txt
    

    Execute cat requirements.txt para ver a lista de dependências instaladas.

  4. Antes de iniciar o CueGUI ou o CueSubmit, defina variáveis obrigatórias para implantação.

    export OPENCUE_ROOT=~/OpenCue
    export CUEBOT_HOSTS=localhost
    export PYTHONPATH=$OPENCUE_ROOT/pyoutline/:$OPENCUE_ROOT/pycue/:$OPENCUE_ROOT/cuesubmit/:$OPENCUE_ROOT/cuegui/
    
    Variável de ambiente Explicação
    CUEBOT_HOSTS=localhost Referência à maneira como o PyCue se conecta à instância do Cuebot. Ele é definido como localhost durante o uso do encaminhamento SSH. Se você estiver usando uma VPN ou uma interconexão dedicada, digite o endereço IP do Cuebot.
    PYTHONPATH=$OPENCUE_ROOT Define o caminho do Python para as bibliotecas do OpenCue.

Compilar protótipos do gRPC

O OpenCue usa o gRPC como o protocolo de comunicação para enviar mensagens entre o servidor e os clientes. Os serviços do gRPC são definidos com buffers de protocolo em um arquivo .proto de linguagem neutra. Para permitir que as bibliotecas Python do OpenCue se comuniquem usando o gRPC:

  • Compile os arquivos de definição .proto em arquivos legíveis em Python com os seguintes comandos:

    cd ~/OpenCue/proto
    python -m grpc_tools.protoc -I=. --python_out=$OPENCUE_ROOT/pycue/opencue/compiled_proto --grpc_python_out=$OPENCUE_ROOT/pycue/opencue/compiled_proto ./*.proto
    

Como executar as interfaces

Nos próximos passos, você explora o OpenCue enviando um job com o CueSubmit. Além disso, explora as configurações dos jobs e renderiza os hosts com o CueGUI. Ambas as ferramentas usam o mesmo ambiente. Dessa maneira, coloque esses processos em segundo plano ao executá-los no shell do ambiente virtual.

Executar o CueSubmit

  • No shell do ambiente de VM, execute o CueSubmit para enviar um job:

    cd ~/OpenCue
    python cuesubmit/cuesubmit &
    

Enviar um job

Usando a interface do CueSubmit, insira as seguintes variáveis:

  1. Digite um nome do job. Por exemplo, yourjobname.
  2. Insira uma sequência, por exemplo, sh_05.
  3. Digite um nome de camada, por exemplo, render.
  4. Em Comando a ser executado, digite:

    /usr/local/blender/blender -b -noaudio /shots/robotdanceparty/sh_05/sh_05_lores.blend -o /shots/renderimages/sh_05.lores.##### -F JPEG -f #IFRAME#
    
  5. Em especificação de frame, digite 600-700.

  6. Defina o Tipo de job para Shell.

  7. Defina Serviços para shell.

  8. Não altere o restante dos padrões e clique em Criar.

    Uma janela é exibida anunciando "Job enviado para o OpenCue". Ela inclui um código e um nome de job para ajudar você a acompanhá-lo durante a renderização.

    Opções de linha de comando para renderização:

    Opção da linha de comando Descrição
    /usr/local/blender/blender Caminho para o executável do blender.
    -b Renderizador da sinalização a ser executado sem interface.
    -noaudio Renderizador da sinalização a ser carregado sem bibliotecas de áudio.
    /shots/robotdanceparty/sh_05/sh_05_lores.blend Caminho para o arquivo de cena a ser renderizado.
    -o /shots/renderimages/sh_05.lores.##### Defina o caminho de saída, o nome e o preenchimento do frame. ##### resulta no quadro 650 sendo sh_05.00650.jpg no disco.
    -F JPEG Define o tipo de arquivo de saída como JPEG.
    -f #IFRAME# Define o número do frame no momento da renderização e é específico do OpenCue. <Frame Spec> interage com essa variável. Portanto, insira-a exatamente como está aqui.

    Para mais informações sobre a renderização da linha de comando do Blender, consulte a documentação do Blender.

    Janela de job enviado

    Variável Explicação
    Nome do job Uma variável arbitrária escolhida no início. A maioria das instalações segue convenções de nomenclatura para ativar jobs de rastreamento com consistência.
    Nome do usuário Preenchido pelo OpenCue. Ele é registrado quando o usuário inicia o CueSubmit.
    Mostrar O OpenCue cria um show padrão chamado testing no início. A maioria das instalações chama projetos de filmes individuais ou shows comerciais neste contexto. A adição e a edição de shows são mais bem feitas usando-se as ferramentas de linha de comando do CueAdmin.
    Sequência Uma de uma série de frames assistidos por um período ininterrupto. Em um cenário de filme, uma sequência é o tempo entre "Ação" "e" "Cortar". Normalmente usada para tomadas individuais em uma sequência ou rotações de recursos durante a pré-produção.
    Camada Um comando individual dentro de um envio e um intervalo de frames. Neste exemplo, você está executando uma única camada, renderizar, no job.
    Comando a ser executado O comando que a camada executará. Aqui, você está executando uma renderização de linha de comando do Blender.
    Especificação do frame Os frames a serem processados. Você renderiza do frame 600 ao 700 da animação. Aponte para a caixa Especificação do frame para ver mais opções, como o aumento dos frames e as entradas de frame arbitrárias.
    Tipo de job Usado para definir o pacote de software utilizado nessa camada em um job. O comando definido é interpretado como um script do shell. Por isso, digite Shell.
    Serviços Uma lista de requisitos, como o mínimo de RAM ou um recurso definido pelo usuário. O job não exige requisitos específicos além do shell. Por isso, selecione Shell.
    Detalhes do envio O resultado combinado das configurações.

Visão geral do CueGUI

O CueGUI é a interface central para uma coleção de módulos de IU, cada um focado em diferentes aspectos do farm de renderizações. Veja a seguir uma lista de termos comuns, explicações e módulos relacionados usados para monitorar o job e renderizar os hosts. Para uma visão geral visual mais aprofundada do CueSubmit e do CueGui, assista a este tutorial em vídeo.

Termo Explicação Módulo do CueGUI relacionado
job Um envio individual para o OpenCue. Monitorar jobs
Atributos
camada Um comando individual dentro de um envio e um intervalo de frames. Neste exemplo, você está executando uma única camada, renderizar, no job. Monitorar detalhes do job
Atributos
host de renderização Um recurso de renderização individual usado para processar uma tarefa. Monitorar detalhes do job
Monitorar hosts
LogView
Atributos
registros Os hosts de renderização gravam arquivos de registros em disco que podem ser analisados em busca de informações, como solução de problemas ou métricas de desempenho. Monitoramento dos detalhes do job
LogView
atributos Uma lista de detalhes sobre um envio ou um recurso do OpenCue. A janela Atributo pode carregar detalhes sobre um job, uma camada ou um host de renderização. Monitorar jobs
Monitorar detalhes do job
Monitorar hosts
Atributos
tag Um método de categorização que pode ser adicionado a um host ou uma camada para relacioná-lo a determinados trabalhos. Adicione tags de hosts para os recursos disponíveis em cada host de renderização e tags de camada para os recursos necessários ao processamento dessa camada. Monitorar detalhes do job
Monitorar hosts
Atributos
tag de camada Uma tag que define os requisitos necessários para processar uma camada. Por exemplo, uma camada pode exigir uma GPU. Por isso, você adicionaria uma tag GPU à camada. Monitorar detalhes do job
Monitorar hosts
Atributos
tag de host Uma tag que define um recurso que um host tem disponível. Por exemplo, é possível adicionar um recurso de GPU a um host que tenha uma GPU instalada.
Um host selecionará uma camada para renderizar se essas tags e uma lista de requisitos de recursos forem atendidas.
Monitorar detalhes do job
Monitorar hosts
Atributos

Neste tutorial, não falamos sobre toda a interface e os conceitos do OpenCue. Consulte a documentação para informações mais detalhadas.

Executar o CueGUI

  • No mesmo shell de ambiente virtual, abra o CueGUI:

    cd ~/OpenCue
    python cuegui/cuegui &
    

Abrir a janela "Monitorar jobs"

  • Quando a janela do CueCommander for aberta, selecione Visualizações/plug-ins > Cuetopia > Monitorar jobs.

Sobre a janela "Monitorar jobs"

A janela Monitorar jobs funciona no nível do job. Dessa maneira, ela funciona como uma visualização geral.

Janela &quot;Monitorar jobs&quot; no OpenCue

Na linha que contém [Your Job], procure as seguintes informações relevantes para este tutorial:

  • Job: o nome do job está listado aqui.
  • Estado: este job está Em andamento, porque ele foi selecionado e está sendo renderizado. Quando o job é concluído, Estado muda para Concluído. Se o job tiver um problema, "Estado" mudará para Falha, e a solução de problemas será necessária. Para mais informações sobre como solucionar problemas de renderizações no OpenCue (em inglês), consulte a documentação.
  • Concluído/total: apresenta uma visão geral do andamento do job. Na imagem, 100 frames foram concluídos de um job de 101 frames.
  • Em execução: informa quantos frames estão em processamento em hosts de renderização. Nesta imagem, somente um frame está em processamento.
  • Progresso: apresenta uma visão geral do andamento do job.

Explorar a janela "Monitorar jobs"

  1. Monitore o andamento do job na janela Monitorar jobs. O job precisa ser Em andamento. Se ele for Falha, consulte a seção Solução de problemas.
  2. Passe o cursor do mouse sobre a palavra Andamento. Uma janela de descrição é exibida com informações úteis sobre a ferramenta.
  3. Explore a interface passando o cursor do mouse sobre os outros títulos e ícones de linha.
  4. Selecione [Your Job].

Abrir a janela "Monitorar detalhes do job"

  1. Para abrir a janela Monitorar detalhes do job, selecione Visualizações/plug-ins > Cuetopia > Monitorar detalhes do job.
  2. Na janela Monitorar jobs, clique duas vezes em [Your Job] para carregar os dados na janela Monitorar detalhes do job.

Sobre a janela "Monitorar detalhes do job"

A janela Monitorar detalhes do job funciona no nível da camada e contém informações detalhadas sobre o job.

Janela &quot;Monitorar detalhes do job&quot; no OpenCue

O módulo Monitorar detalhes do job contém duas janelas:

  • Painel Camada. Na janela com [Your Job] na barra de título, você vê o nome da camada.
  • Painel Informações da camada. Nesta janela, você vê informações relacionadas a cada frame da camada selecionada.

Visão geral do painel Camada:

  • Camada: o job tem uma camada, renderização. Se o job tivesse várias camadas, elas seriam listadas aqui e seriam selecionáveis individualmente com um clique duplo.
  • Média: a média por tempo de renderização de frame dessa camada.
  • Tags: as tags no nível da camada são listadas aqui. A definição de tags não está no escopo deste tutorial, mas esse é o local para acessar tags no nível da camada.
  • Dependências: as dependências de camada são listadas aqui. O gerenciamento de dependências não está no escopo deste tutorial, mas esse é o local para acessar dependências no nível da camada.

Visão geral do painel Informações da camada:

  • Botão Atualizar: clique neste botão para recarregar a interface com as informações mais recentes do banco de dados.
  • Ordem: a ordem em que os frames são renderizados, listados aqui porque eles podem ser renderizados em ordem arbitrária. Por exemplo, é possível renderizar a cada 10 frames e depois o restante, ou na ordem inversa. Essa ordem é especificada no CueSubmit usando o Frame Spec quando você envia o job.
  • Frame: o número do frame da cena que será renderizada.
  • Status: o status do frame. Na imagem, esses frames foram Bem-sucedidos.
  • Host: o endereço IP do host de renderização atribuído ao frame.

Explorar a janela "Monitorar detalhes do job"

  1. Clique em Atualizar e examine o andamento do job na janela Monitorar detalhes do job.
  2. Passe cursor do mouse sobre a palavra Status, e uma janela de descrição é exibida com informações úteis sobre a ferramenta.
  3. Explore a interface passando o cursor do mouse sobre os outros títulos e ícones de linha.

Abrir a janela "LogView"

  • Para abrir a janela LogView, selecione Visualizações/plug-ins > Outros > LogView.

Sobre a janela "LogView"

A janela LogView apresenta uma visualização rápida de registros de frames individuais. Essa visualização pode ser útil para coletar informações para solução de problemas, dimensionar VMs corretamente para passagens de renderização futuras ou durante a otimização de renderizações.

Janela &quot;Visualização do registro&quot; no OpenCue

Um arquivo de registro começa com um cabeçalho contendo dados específicos do OpenCue e acompanha a saída do software que processa a imagem. Nesta instância, você vê a configuração do OpenCue seguida da saída de registro do Blender.

Explorar a janela "LogView"

  1. Na janela Monitorar detalhes do job, selecione um frame identificado como SUCCEEDED no painel Informações da camada para examinar registros.
  2. Observe o comando em execução.
  3. Observe o logDestination.

Saiba mais sobre a janela LogView na documentação do OpenCue (em inglês).

Abrir a janela "Monitorar hosts"

  • Para abrir a janela Monitorar hosts, selecione Visualizações/plug-ins > CueCommander > Monitorar hosts.

Sobre a janela "Monitorar hosts"

A janela Monitorar hosts fornece informações sobre hosts de renderização individuais e é uma interface para adicionar ou remover recursos usando tags.

Janela &quot;Monitorar hosts&quot; no OpenCue

As seguintes informações são pertinentes a este tutorial:

  • Atualização automática: marque esta caixa para recarregar a janela Monitorar hosts.
  • Atualização: clique neste botão para recarregar a janela Monitorar hosts.
  • Endereço IP: o endereço IP facilita o rastreamento de VMs entre o OpenCue e o Google Cloud.
  • % de carga: média da carga no host, um bom indicador de uso da máquina.
  • Memória: alocação da memória de host.
  • Tags: recursos registrados no host.

Explorar a janela "Monitorar hosts"

  1. Clique em Atualizar ou marque a caixa de seleção Atualização automática.
  2. Selecione um host de renderização clicando no Endereço IP.
  3. Clique com o botão direito no host de renderização para ver mais opções, como Excluir host ou Adicionar ou remover tags.

    Para mais informações sobre como gerenciar recursos com tags, consulte a documentação.

  4. Clique duas vezes em um host para verificar os atributos.

  5. Observe a alocação, que é definida como local.general.

  6. Observe as tags, que são general e o endereço IP do host.

Abrir a janela "Atributos"

  • Selecione Visualizações/plug-ins > Outros > Atributos.

Sobre a janela "Atributos"

A janela Atributos apresenta uma lista de detalhes em um host de renderização, uma camada ou um job. Abaixo está um exemplo de cada um.

Janela &quot;Atributos&quot; do OpenCue

Cada janela contém informações pertinentes ao host, à camada ou ao job. A tag facility local em Atributos do job e a tag general em Atributos da camada são indicadores-chave dos requisitos desse envio. Os frames desse job só selecionam hosts de renderização com ambas as tags atribuídas. Você vê essas tags atribuídas em Atributos do host visualizando a alloc e a linha tags.

Explorar a janela "Atributos"

  1. Na janela Monitorar hosts, clique em um Endereço IP de host de renderização para carregar os atributos.
  2. Na janela Atributos, verifique as configurações alloc e tags.
  3. Na janela Monitorar detalhes do job, clique em um frame Succeeded para carregar os atributos.
  4. Na janela Atributos, explore as configurações minMemory e tags.
  5. Na janela Monitorar jobs, clique em um job.
  6. Na janela Atributos, explore as configurações facility e minCores.

Para uma explicação mais completa, consulte Referência do CueGUI.

Como verificar frames renderizados

Há várias maneiras de verificar frames à medida que eles são renderizados ou copiá-los localmente após a conclusão. Está além do escopo deste tutorial instalar ferramentas de visualização de animação, mas é possível usar o Console do Cloud para ver frames individuais ou fazer o download deles localmente para exibi-los em seu aplicativo de visualização de imagens favorito.

  1. No Console do Cloud, veja uma lista de objetos em um bucket ou visualize imagens em um navegador:

    ACESSAR A PÁGINA DO CLOUD STORAGE

  2. Clique em [YOUR_BUCKET_NAME] e, em seguida, clique em renderimages para ver uma lista de frames.

  3. Clique em uma imagem, por exemplo, sh_05_lores.00650.jpg, para uma visualização da janela do navegador.

  4. Use o shell local para listar as imagens no diretório de saída:

      ls /shots/renderimages
    

    Também é possível copiar arquivos localmente ou abrir na ferramenta de visualização de sua preferência.

  5. Use gsutil para listar objetos em um bucket:

    gsutil ls gs://[YOUR_BUCKET_NAME]/renderimages
    
  6. Use gsutil copiar todos os objetos no seu bucket para um diretório local, [LOCAL_DIRECTORY].

    mkdir ~/[LOCAL_DIRECTORY]
    gsutil -m rsync -r gs://[YOUR_BUCKET_NAME]/renderimages ~/[LOCAL_DIRECTORY]
    

Como assistir ao job completo

Se a renderização ainda estiver sendo processada, será possível optar por concluí-la e explorar o OpenCue depois ou parar a renderização encerrando-a na janela Monitorar jobs.

Para encerrar o job no OpenCue:

  1. Abra a janela Monitorar jobs.
  2. Selecione [Your Job] e clique no botão Encerrar job.
  3. Um pop-up pergunta: "Você tem certeza de que quer encerrar esses jobs?".
  4. Clique em OK para encerrar o job.

(Opcional) Como explorar opções para o farm de renderizações

Para manter este tutorial dentro de um limite de oito vCPUs no total, você implantou alguns hosts de renderização de tamanho modesto na tarefa de renderização. Suponhamos que a meta seja concluir o job rapidamente ou criar uma animação pronta para o cinema. Nesse caso, é possível implantar um número maior de recursos com mais CPUs modificando o modelo de instância atual para usar uma vCPU n1-highcpu-4 ou superior e criando um grupo de instâncias gerenciadas para controlar o número total de hosts de renderização disponíveis para o job.

Você processou o seguinte arquivo de cena de baixa resolução, em VMs n1-standard-2, em cerca de 1 minuto por frame.

  • Arquivo de cena:

    gs://[YOUR_BUCKET_NAME]/robotdanceparty/sh_05/sh_05_lores.blend
    
  • Imagem resultante:

    Imagem de baixa resolução da festa da dança do robô

    O bucket do tutorial contém um arquivo de cena de alta resolução que, quando renderizado, cria imagens semelhantes a essas em cerca de 8 minutos usando uma VM n1-highcpu-4.

    Se você quiser testar outras opções no OpenCue, faça upgrade do comando CueSubmit para fazer referência a esse arquivo de resolução mais alta.

  • Arquivo de cena:

    gs://[YOUR_BUCKET_NAME]/robotdanceparty/sh_05/sh_05.blend
    
  • Imagem resultante:

    Resolução um pouco maior da mesma imagem do robô

(Opcional) Como solicitar uma alteração feita na cota

Se você quiser aumentar o número de hosts de renderização ou usar VMs maiores, poderá ser necessário aumentar a cota do projeto.

  1. Acesse a página Cotas.

    ACESSAR A PÁGINA "COTAS"

  2. Na página Cotas, selecione as que você quer alterar.

  3. Clique no botão Editar cotas na parte superior da página.

  4. Marque a caixa do serviço que você quer editar.

  5. Forneça o nome, o e-mail e o número de telefone e clique em Próxima.

  6. Insira a solicitação para aumentar a cota e clique em Próxima.

  7. Envie a solicitação.

Solução de problemas


Problema: problemas no processo de criação do Docker.

Solução: tente criar o Dockerfile com a sinalização --no-cache, forçando o Docker a usar dados recentes para todas as etapas. Para mais informações sobre opções de criação do Docker (em inglês), consulte a documentação.


Problema: erro Connect Failed no shell ao iniciar o CueSubmit ou o CueGUI. Geralmente algo semelhante a:

Encountered a server error. StatusCode.UNAVAILABLE : Connect Failed

Solução: verifique se o túnel SSH está funcionando e reinicie o CueSubmit ou o CueGUI.

  1. Execute o comando "Status do processo" em um shell local para garantir que o túnel SSH esteja aberto:

    ps aux | grep ssh.
    

    Uma lista de processos é exibida. Um deles precisa ter uma saída semelhante a esta, com [USER_NAME], [PROJECT_NAME] e o SO:

    [USER_NAME]     75335   0.0  0.3  4392464  54736 s002  T     3:03PM   0:00.84  /usr/local/Cellar/python@2/2.7.15_1/Frameworks/Python.framework/Versions/2.7/Resources/Python.app/Contents/MacOS/Python -S /Users/[USER_NAME]/google-cloud-sdk/lib/gcloud.py compute ssh cuebot --project [PROJECT_NAME] --zone us-central1-a -- -N -L 8443:127.0.0.1:8443
    
  2. Verifique se [USER_NAME], [PROJECT_NAME], --zone e nome (cuebot) estão corretos para a implantação.

  3. Pare o processo SSH e refaça os passos na seção "Configurar encaminhamento SSH" deste documento para abrir um novo túnel SSH.


Problema: CueSubmit ou CueGUI abrem, mas imprimem erros no shell de inicialização.

Solução: conecte-se à instância do Cloud SQL e verifique se ela foi preenchida com dados de esquema e exemplo. Se você não vir o resultado esperado, reimporte os arquivos na seção Criar um banco de dados do Cloud SQL. Consulte a etapa "Importar o esquema do banco de dados e os dados de demonstração".

  1. No Console do Cloud, acesse o Cloud Shell e execute o seguinte comando para atualizar sua instância do Cloud SQL. Substitua [CLOUD_SQL_INSTANCE_ID] pelo nome da instância.

    gcloud sql connect [CLOUD_SQL_INSTANCE_ID] --user=postgres
    
  2. Quando solicitado, atualize [DATABASEPASSWORD] e pressione Enter:

    [DATABASEPASSWORD]
    
  3. Digite o seguinte comando e pressione Enter:

    \c cuebot
    
  4. Digite novamente a senha quando solicitado e pressione Enter:

    [DATABASEPASSWORD]
    
  5. Digite o seguinte comando:

    \d+
    

    A saída pode ser como esta:

    >
    List of relations
    Schema | Name     | Type  | Owner    | Size       | Description
    -------+----------+-------+----------+------------+-------------
    public | action   | table | postgres | 8192 bytes |
    public | alloc    | table | postgres | 8192 bytes |
    public | comments | table | postgres | 8192 bytes |
    public | config   | table | postgres | 8192 bytes |
    public | deed     | table | postgres | 0 bytes    |
    public | depend   | table | postgres | 0 bytes    |
    public | dept     | table | postgres | 8192 bytes |
    

Problema: erros no shell do CueSubmit ou do CueGUI, e nenhuma ferramenta será executada.

Solução: confira se a conexão entre o CueBot e o banco de dados funciona verificando as seguintes variáveis:

  1. Verifique se você digitou [RESERVED_STATIC_IP_ADDRESS] corretamente no passo "Rede" da seção Criar uma instância do Cloud SQL.
  2. Verifique se você digitou [CLOUD_SQL_IP_ADDRESS] e [DATABASEPASSWORD] corretamente no passo "Argumentos de comando" da seção Como configurar e provisionar a VM do Cuebot.
  3. Verifique se você digitou corretamente o endereço IP externo reservado no passo "Definir configurações de rede" da seção Como configurar e provisionar a VM do Cuebot.

Problema: um job iniciado é listado no OpenCue, mas não é selecionado em hosts de renderização.

Solução: verifique se as tags Job Facility e Job Layer correspondem às tags Render Host atribuídas e se os requisitos mínimos de recursos foram atendidos. Para mais informações, consulte os documentos Solução de problemas de renderização e Solução de problemas de implantação do OpenCue (páginas em inglês).


Problema: os hosts de renderização não estão visíveis no CueGui.

Solução: vários problemas podem deixar os hosts invisíveis. O mais provável é que o endereço IP interno do Cuebot tenha sido digitado incorretamente durante a implantação do modelo de instância do host de renderização. Para mais informações, consulte a documentação Solução de problemas de implantação.

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir