Crea una granja de procesamiento en GCP con OpenCue

Fiesta de robots

En este instructivo, se muestra cómo implementar el sistema de administración de renderización de OpenCue en máquinas virtuales (VM) de Linux mediante Google Cloud. Te tomará entre 3 y 4 horas completar todo el instructivo.

Las herramientas de administración de renderización se usan en efectos visuales y producciones de animación para dividir los trabajos complejos en tareas individuales y distribuirlos en una amplia gama de recursos de procesamiento. Estas herramientas se usan para administrar trabajos, como la renderización en 3D, la composición en 2D, la transcodificación de datos de un formato a otro y la verificación de recursos dentro y fuera de las bases de datos. A menudo, las herramientas se usan para vincular las dependencias y las etapas de trabajo. En instalaciones más grandes, un sistema de administración de renderización puede admitir miles de trabajos simultáneos y proporcionar la interfaz para asignar recursos a cada etapa de trabajo, administrar registros, solucionar problemas de las herramientas y administrar recursos.

Google colaboró con Sony Pictures Imageworks a fin de lanzar OpenCue, un sistema de administración de renderización de código abierto apto para la producción que funciona en Linux y macOS. OpenCue se usa para crear granjas de renderización locales y para implementaciones híbridas a gran escala hechas mediante recursos de varios proveedores de servicios en la nube.

Este instructivo está dirigido a administradores de TI y directores técnicos de canalizaciones que estén familiarizados con las siguientes herramientas y conceptos. No te preocupes si no eres experto en todo lo que figura en esta lista. Indicaremos más recursos cuando corresponda.

  • Principios operativos de la administración de renderización distribuida
  • Git y GitHub
  • Docker para crear y ejecutar contenedores
  • Secuencias de comandos de Bash para editar secuencias de comandos y ejecutar recursos
  • Configuración y edición de secuencias de comandos de Python
  • Herramientas y conceptos básicos de la administración de recursos de Google Cloud, incluidos Cloud SQL, Compute Engine, Cloud Storage y Container Registry

Debido a que las herramientas de administración de renderización abarcan varios casos prácticos y organizan una amplia gama de recursos, existen muchas formas de configurar una granja de renderización. En este instructivo, nos enfocaremos en una sola configuración, lo que te permitirá comenzar a trabajar con OpenCue lo más rápido posible. Crear una arquitectura óptima para tu granja de renderización puede requerir una modificación de los pasos, un perfilado del rendimiento de tu flujo de trabajo o un intercambio de tipos de recursos de Google Cloud. Si deseas obtener más información sobre las opciones para configurar y administrar una granja de renderización en Google Cloud, consulta Compila una granja de renderización híbrida. Para obtener más información sobre cómo proteger tus datos, consulta Protección de las cargas de trabajo de renderización.

Objetivos

  • Instalar y configurar módulos de OpenCue mediante Docker y Python
  • Crear una base de datos de OpenCue y propagar datos de esquema y de ejemplo en ella
  • Crear recursos de Cloud Storage y propagarlos con los archivos de escena de animación del instructivo
  • Crear y configurar imágenes de Docker de forma local, almacenarlas en Container Registry y, luego, iniciar los recursos de Compute Engine mediante contenedores
  • Crear plantillas de instancias y grupos de instancias administrados para habilitar el escalamiento eficiente de los recursos de procesamiento
  • Configurar una estación de trabajo para ejecutar la interfaz de OpenCue de forma local
  • Renderizar una secuencia de animación y explorar la administración de trabajos mediante la interfaz de OpenCue

Costos

Puedes usar la calculadora de precios para generar una estimación de costos según el uso previsto.

En este instructivo, se analiza cada paso de la compilación de una granja de renderización en funcionamiento con restricciones estrictas de cantidad de máquinas y tamaño. Para cumplir con los lineamientos de precios del Nivel gratuito de Google Cloud, en este instructivo renderizarás una animación con baja resolución y tasas de muestreo en unas pocas VM y con dos CPU virtuales.

El costo de los recursos que conforman este instructivo, si se usan durante un total de 4 horas, equivale a $3.27.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir a la página del selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

  4. Habilita las API de Container Registry and Compute Engine.

    Habilita las API

  5. Asegúrate de tener instalado lo siguiente en tu máquina local:
    • Docker. Este instructivo se prueba con la versión 18.09.0 de Docker Engine.
    • Python. Este instructivo se prueba con la versión 2.7.10.
    • Pip. Este instructivo se prueba con la versión 19.0.
    • Virtualenv. Este instructivo se prueba con la versión 16.2.0.
    • gcsfuse. Este instructivo se prueba con la versión 0.23.0.
    • La versión más reciente del SDK de Cloud. En este instructivo, se requiere que instales el SDK de Cloud para usar las herramientas de línea de comandos de gcloud y gsutil. Debes ejecutar las herramientas de gcloud y gsutil en una terminal de tu estación de trabajo local.

Descripción general de OpenCue

La interfaz de OpenCue usa varios módulos y comandos, así como varios conceptos y términos únicos. Las siguientes herramientas y técnicas se usan para implementar una granja de renderización híbrida básica. Para obtener información sobre temas más avanzados y diferentes opciones de implementación, consulta la documentación de OpenCue.

  • Cuebot: La herramienta de programación de OpenCue. Cuebot controla la distribución de trabajos, administra los recursos de renderización y se comunica con la base de datos. Se puede acceder a Cuebot mediante Python y Bash a través de una interfaz de línea de comandos (CLI), pero también se incluye una interfaz visual como un módulo independiente, que se describe más adelante. En este ejemplo, debes ejecutar Cuebot en una VM de Google Cloud. También puedes ejecutarlo de forma local para implementaciones locales. Puedes usar varias instancias de Cuebot a fin de tener alta disponibilidad para implementaciones híbridas o más grandes.
  • Base de datos: Cuebot interactúa con un servidor de base de datos de PostgreSQL para almacenar el estado de la aplicación. Solo se comparte una base de datos entre las instancias, incluso en una implementación con varios Cuebots. Para este instructivo, usamos una instancia de Cloud SQL a fin de facilitar la implementación.
  • CueGUI: La interfaz visual para interactuar con Cuebot. CueGUI se usa para supervisar y administrar la configuración de los trabajos y los hosts de renderización. En este instructivo, ejecutarás Cuebot en la nube y CueGUI en tu máquina local.
  • Hosts de renderización: Recursos de renderización individual que se usan para procesar tareas individuales. Estos hosts pueden ser locales, estar en la nube, o una combinación de ambos. En este instructivo, usarás un grupo de instancias administrado de VM en Google Cloud como hosts de renderización.
  • RQD: Daemon de renderización en cola que se ejecuta en hosts de renderización individuales y que interactúa con Cuebot para enviar y recibir instrucciones sobre los comandos que se deben ejecutar.
  • CueSubmit: GUI para iniciar y configurar trabajos. Puedes ejecutar este programa de Python como una GUI independiente o como un complemento en software de terceros. En OpenCue, se incluye un complemento de Maya (probado con la versión 2017 y posteriores) y uno de Nuke (probado con la versión 11). El repositorio de OpenCue incluye un código que puedes modificar a fin de compilar tus propios complementos para otras herramientas de terceros o personalizar tu canalización.
  • PyCue: Una colección de bibliotecas de Python que se usa para interactuar con Cuebot. Puedes usar estas bibliotecas si deseas compilar más herramientas o para comunicarte con Cuebot mediante la línea de comandos en vez de a través de una GUI.
  • PyOutline: Biblioteca de Python para compilar envíos de trabajos de OpenCue. PyOutline permite compilar una especificación de trabajo y definir las dependencias. En este instructivo, no interactúas directamente con este módulo, ya que CueSubmit lo llama en segundo plano.
  • CueAdmin: Una herramienta de línea de comandos que usa la API de PyCue para Python a fin de administrar OpenCue.

Arquitectura del programa de OpenCue

En el siguiente diagrama de arquitectura, se ilustra cómo se conectan y se comunican los módulos de OpenCue.

Diagrama de arquitectura de OpenCue

Recursos de Google Cloud que se usaron en este instructivo

En el siguiente diagrama de arquitectura, se ilustran los recursos de Google Cloud necesarios para completar este instructivo.

Recursos de Google Cloud necesarios para completar este instructivo

Descarga el repositorio de OpenCue

El repositorio oficial de OpenCue está alojado en GitHub.

  • Navega al lugar de trabajo y al directorio que usarás en este instructivo y descarga el repositorio de OpenCue:

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

Crea un bucket de Cloud Storage y propaga los archivos del instructivo en él

En este instructivo, se usa un depósito de Cloud Storage para almacenar todos los archivos de escenas de animación y otras dependencias de archivos de entrada, así como archivos de registro finales de resultados procesados y de host de procesamiento.

En un paso posterior, instalarás y usarás Cloud Storage FUSE (gcsfuse). Esta herramienta es un adaptador de FUSE de código abierto que puedes usar para activar depósitos de Cloud Storage como sistemas de archivos en tus hosts de renderización de Linux y en tu máquina local. gcsfuse proporciona una opción de almacenamiento económica y eficaz para este flujo de trabajo. Sin embargo, puedes mejorar de forma notable el rendimiento de algunos trabajos si haces coincidir los trabajos individuales con un perfil de almacenamiento optimizado según sus necesidades específicas. Google Cloud tiene muchas opciones de almacenamiento, pero está fuera del alcance de este documento cubrir las ventajas y desventajas de cada flujo de trabajo. Para obtener más información sobre las opciones de almacenamiento, consulta Compila una granja de renderización híbrida o comunícate con un representante de Google Cloud si deseas adaptar una opción de almacenamiento a tus necesidades.

Crea un bucket de Cloud Storage

Antes de crear un bucket, asegúrate de estar en el proyecto correcto:

  • Crea un depósito de Cloud Storage [YOUR_BUCKET_NAME] para almacenar los datos del instructivo.

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

    El comando de gsutil hace referencia a la creación de recursos en la región us-central1.

Sincroniza los datos del instructivo con el bucket

El bucket de Cloud Storage contiene alrededor de 950 MB de datos para este instructivo. Usa gsutil rsync para sincronizar los datos de la fuente con un bucket de destino sin tener que descargar estos datos en tu máquina local. Observa la marca -r, que copia subdirectorios recurrentes, y la marca -m, que se sincroniza en paralelo y es útil cuando se trabaja con varios archivos.

  1. Crea una variable de entorno para el nombre de tu bucket de Cloud Storage:

    export YOUR_BUCKET=[YOUR_BUCKET_NAME]

  2. Sincroniza los datos de ejemplo con el bucket:

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

Sube el esquema y los datos de la base de datos de ejemplo

Sube el esquema de la base de datos y los datos de demostración para propagar la tabla de la base de datos:

  1. Copia los archivos V1__Initial_schema.sql, V2__Add_limit_table.sql y V3__increase_show_length.sql del directorio local de OpenCue al depósito del instructivo de Cloud Storage:

    gsutil cp ~/OpenCue/cuebot/src/main/resources/conf/ddl/postgres/migrations/* gs://$YOUR_BUCKET/database/

  2. Copia el archivo demo_data.sql del directorio local de OpenCue al depósito del instructivo de Cloud Storage:

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

Implementa la base de datos

El módulo Cuebot de OpenCue almacena datos de estado para el programa en una base de datos de PostgreSQL. Para este instructivo, primero debes reservar una IP externa de la VM que funciona como Cuebot. Luego, aprovisiona y configura una instancia de Cloud SQL, configura la conectividad de red mediante la inclusión de la dirección IP de Cuebot en la lista blanca y, finalmente, propaga la base de datos con un esquema y datos de demostración.

Reserva una dirección IP externa estática para Cuebot

Antes de crear la base de datos o la VM para Cuebot, reserva una IP externa estática a fin de que la VM de Cuebot se use en la comunicación de red entre estos dos recursos:

  1. Ve a la página Reserva una dirección estática en Cloud Console.

    IR A LA PÁGINA RESERVA UNA DIRECCIÓN ESTÁTICA

  2. Elige un nombre para la dirección nueva, por ejemplo, cuebotstaticip.

  3. En Nivel de servicio de red, especifica Premium.

  4. En Versión de IP, especifica IPv4.

  5. En Tipo, elige Regional.

  6. Selecciona la región us-central1.

  7. Deja Conectado a como Ninguno.

  8. Haz clic en Reservar si deseas reservar la IP.

Después de crear el recurso, se te redireccionará a la página Direcciones IP externas. Debes hacer referencia a esta dirección como [RESERVED_STATIC_IP_ADDRESS].

Crea una instancia de Cloud SQL

Existen muchas opciones para crear una base de datos de PostgreSQL. En este instructivo, se usa Cloud SQL, que ofrece una configuración sencilla y una base de datos completamente administrada en Google Cloud. En esta instancia, se usa SSD para las operaciones de lectura y escritura rápidas, pero existe una capacidad de almacenamiento inicial pequeña de solo 1 CPU virtual y 3.75 GB de RAM. Cuando escalas OpenCue en implementaciones más grandes, este recurso es uno de los primeros que te recomendamos agrandar, y Cloud SQL puede escalar a la par de tu implementación.

  1. Ve a la página Instancias de Cloud SQL en Cloud Console.

    IR A LA PÁGINA INSTANCIAS DE CLOUD SQL

  2. Selecciona el proyecto y haz clic en Continuar.

  3. Haz clic en Crear instancia.

  4. Haz clic en PostgreSQL.

  5. Ingresa un ID de instancia, por ejemplo, opencuedatabase.

  6. Ingresa una contraseña para el usuario de postgres predeterminado. Cuando creas Cuebot, debes hacer referencia a esta contraseña como [DATABASEPASSWORD].

  7. Establece la Región en us-central1 y la Zona en us-central1-a.

  8. Configura las opciones de conectividad de la siguiente manera:

    1. Abre Mostrar opciones de configuración y selecciona Conectividad.
    2. Selecciona IP pública y Agregar red.
    3. En Red, ingresa tu [RESERVED_STATIC_IP_ADDRESS].
    4. Haz clic en Crear.

    Regresarás a la lista de instancias. La instancia nueva se ve atenuada mientras se inicializa y comienza.

Crea una base de datos de Cloud SQL

  1. En la página Detalles de la instancia de tu recurso de Cloud SQL, selecciona Bases de datos.
  2. Selecciona Crear base de datos.
  3. Establece el Nombre de la base de datos en cuebot.
  4. Haz clic en Crear.

  5. Importa el esquema de la base de datos y los datos de demostración:

    1. Selecciona Importar.
    2. En la línea del archivo de Cloud Storage, haz clic en Explorar.

    3. Navega al depósito de almacenamiento [YOUR_BUCKET_NAME] que subiste y, a continuación, importa el esquema para la base de datos mediante la selección del siguiente archivo:

      gs://[YOUR_BUCKET_NAME]/database/V1__Initial_schema.sql

    4. Configura el Formato de importación como SQL.

    5. En Base de datos, selecciona cuebot.

    6. Selecciona Mostrar opciones avanzadas.

    7. En Usuario, selecciona el usuario postgres.

    8. Haz clic en Importar.

    Cuando finalice la importación, se te redireccionará a la página Detalles de la instancia de Cloud SQL.

    Repite los pasos anteriores para importar los datos de demostración de los siguientes archivos:

    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

Cuando se completen estas importaciones, se te redireccionará a la página Detalles de la instancia de Cloud SQL. Toma nota de la dirección IP de Cloud SQL, que luego se menciona como [CLOUD_SQL_IP_ADDRESS], porque la necesitarás cuando configures Cuebot en un paso posterior.

Prepara una imagen de Docker de Cuebot para la implementación

En este instructivo, se implementa Cuebot como un contenedor de Docker en una sola VM de Compute Engine. Para comenzar, debes compilar una imagen de Docker de Cuebot de manera local desde el repositorio de OpenCue y enviarla a Container Registry. Container Registry es un repositorio privado de imágenes de Docker en Google Cloud que se usa para almacenar las imágenes de Docker en este instructivo. Para obtener más información sobre este flujo de trabajo, consulta la documentación de Compute Engine.

Crea la imagen

  1. Asegúrate de estar en el nivel raíz del repositorio de OpenCue:

    cd ~/OpenCue

  2. Crea una variable llamada TAG_NAME y otra para PROJECT_NAME y, luego, usa Docker a fin de compilar una imagen con esta etiqueta para el seguimiento. Si incluyes gcr.io/[PROJECT_NAME] en el paso de compilación, debes habilitar el etiquetado para una sincronización posterior con 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 .

Sincroniza la imagen con Container Registry

Autoriza la herramienta de gcloud para que Docker pueda subir imágenes a Container Registry. Luego, sincroniza tu imagen de Docker de Cuebot con Container Registry.

  1. Ejecuta el siguiente comando a fin de autorizar la herramienta de gcloud y la sincronización de Docker:

    gcloud auth configure-docker

  2. En el siguiente mensaje, escribe y y, luego, presiona Intro.

    Do you want to continue (Y/n)?

  3. Envía la imagen de Docker de Cuebot desde tu repositorio local a Container Registry:

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

Esta carga toma unos minutos hasta que se completa la sincronización.

Configura y aprovisiona la VM de Cuebot

Usa la consola para aprovisionar una VM con Container Optimized OS, configurar el contenedor, crear una conexión a la base de datos y conectar la dirección IP externa estática reservada.

  1. Ve a la página Instancias de VM.

    IR A LA PÁGINA INSTANCIAS DE VM

  2. Haz clic en el botón Crear instancia para crear una nueva.

  3. Asigna el nombre cuebot a la instancia.

  4. Establece la Región en us-central1 y la Zona en us-central1-a.

  5. En Tipo de máquina, selecciona Personalizar y configura un tipo de máquina de 1 CPU virtual de 6.5 GB.

  6. Configura el Contenedor de la siguiente forma:

    1. En la sección Contenedor, selecciona Implementar imagen de contenedor.

    2. Actualiza [PROJECT_NAME] y especifica la siguiente Imagen de contenedor.

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

    3. Expande Opciones avanzadas de contenedor.

    4. En Argumentos del comando, haz clic tres veces en + Agregar argumento para agregar tres argumentos.

    5. Ingresa los siguientes argumentos del comando y reemplaza [CLOUD_SQL_IP_ADDRESS] y [DATABASEPASSWORD] por tus 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]

      En el comando anterior, se ilustra lo siguiente:

      Argumento del comando Explicación y entrada requerida
      --datasource.cue-data-source.jdbc-url=jdbc:postgresql://[CLOUD_SQL_IP_ADDRESS]/cuebot Habilita la comunicación de Cuebot con la base de datos. La entrada es [CLOUD_SQL_IP_ADDRESS] o [DATABASE_NAME]. Usaste cuebot para el nombre de la base de datos en el paso anterior, por lo que se ingresa aquí.
      --datasource.cue-data-source.username=postgres Cuebot requiere el nombre de usuario de la base de datos cuando se conecta. Durante la configuración, usaste postgres, el nombre de usuario predeterminado, por lo que se ingresa aquí. Para la producción, debes seguir las prácticas recomendadas de seguridad y crear un usuario nuevo con privilegios específicos.
      --datasource.cue-data-source.password=[DATABASEPASSWORD] Cuebot requiere la contraseña de la base de datos cuando se conecta. Ingresa la [DATABASEPASSWORD] aquí.

  7. Establece la configuración de red:

    1. En Herramientas de redes, selecciona Interfaces de red.
    2. Haz clic en IP externa y selecciona cuebotstaticip, la dirección IP externa reservada que se creó antes para Cuebot.
    3. Haz clic en Listo.
    4. Deja el resto de la configuración en los valores predeterminados.
    5. Haz clic en Crear.

La VM toma unos minutos en iniciarse. Toma nota de la dirección IP interna, que necesitarás cuando crees la plantilla de instancias. La dirección se mencionará más adelante como [CUEBOT_INTERNAL_IP_ADDRESS].

Crea hosts de renderización

Los hosts de renderización se componen de VM que se ejecutan como un grupo de instancias administrado (MIG), lo que permite controlar la ubicación y el escalamiento de los recursos. El MIG usa una plantilla de instancia para determinar el tipo de máquina, habilitar la administración de cuentas de servicio, implementar una imagen de contenedor y establecer la configuración de los contenedores y las variables de entorno.

Las imágenes de contenedor se usan para configurar muchas de las dependencias y los paquetes de software necesarios a fin de ejecutar las tareas de renderización del instructivo. Si deseas configurar las imágenes de contenedor para tu proyecto, usa Docker a fin de crear una imagen base de host de renderización y almacenarla en un repositorio local. Puedes personalizar esta base si agregas el software específico para la tarea y la configuración de Google Cloud del repositorio del instructivo antes de implementarla en Container Registry.

Crea la imagen base de host de renderización

  • En tu shell local, crea la imagen base del host de renderización.

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

Configura la imagen de Blender

El Dockerfile y las secuencias de comandos relacionadas que se necesitan para crear la imagen de Blender de host de renderización se encuentran en el repositorio del instructivo. En esta sección, descargarás el repositorio y actualizarás algunas opciones de configuración para que funcionen en tu proyecto.

  1. Navega al directorio y al lugar de trabajo que usas para este instructivo y descarga el repositorio del instructivo.

    cd ~
git clone https://github.com/GoogleCloudPlatform/python-opencue-demo.git

  2. Cuando se inicia el host de renderización, la secuencia de comandos rqd_startup.sh de este repositorio llama a gcsfuse para activar el bucket del instructivo como un sistema de archivos en la ruta de acceso /shots. Abre el Dockerfile en tu editor de texto y actualiza la variable GCS_FUSE_BUCKET para que apunte al bucket del instructivo:

    1. En una shell, copia el siguiente archivo en la raíz del repositorio.

      cp ~/python-opencue-demo/third_party/Dockerfile ~/python-opencue-demo/Dockerfile

    2. En el editor de texto que prefieras, edita el siguiente archivo:

      ~/python-opencue-demo/Dockerfile

    3. Actualiza [YOUR_BUCKET_NAME] con el nombre del depósito en la siguiente línea:

      ENV GCS_FUSE_BUCKET [YOUR_BUCKET_NAME]

    4. Guárdalo y sal del editor de texto.

Compila la imagen y envíala a Container Registry

  1. Compila la imagen:

    cd ~/python-opencue-demo
docker build -t gcr.io/$PROJECT_NAME/opencue/rqd-blender:$TAG_NAME .

  2. Cuando se complete la compilación, envía la imagen a Container Registry:

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

Implementa hosts de procesamiento

Los hosts de renderización deben tener permisos de lectura y escritura cuando se renderizan. Para otorgarles acceso, crea una cuenta de servicio con el principio de seguridad de menor privilegio. Usa esta cuenta para Identidad y acceso a la API cuando aprovisiones tus VM.

Crea una cuenta de servicio

  1. En Cloud Console, ve a la página Cuentas de servicio.

    IR A LA PÁGINA CUENTAS DE SERVICIO

  2. Haz clic en Seleccionar un proyecto.

  3. Selecciona tu proyecto y haz clic en Abrir.

  4. Haz clic en + Crear cuenta de servicio.

  5. Ingresa un [SERVICE_ACCOUNT_NAME], por ejemplo, storageservice, y haz clic en Crear.

  6. Selecciona la función de administrador de objetos de almacenamiento en la cuenta de servicio y haz clic en Continuar.

  7. Haz clic en Listo.

Crea una plantilla de instancias

Mediante la imagen de Docker rqd-blender, crea una plantilla de instancias para determinar el tamaño y la configuración de la VM:

  1. En Cloud Console, ve a la página Plantillas de instancias.

    IR A LA PÁGINA PLANTILLAS DE INSTANCIAS

  2. Haz clic en Crear plantilla de instancias.

  3. Asigna un nombre a la plantilla de instancias, por ejemplo, rqd-blender.

  4. En Tipo de máquina, selecciona n1-highmem-2.

  5. Configura el Contenedor de la siguiente forma:

  6. En la sección Contenedor, selecciona la casilla de verificación Implementar una imagen de contenedor para esta instancia de VM.

  7. Actualiza [PROJECT_NAME] y especifica lo siguiente para Imagen de contenedor:

    gcr.io/[PROJECT_NAME]/opencue/rqd-blender:demo

  8. Permite el acceso a los dispositivos del sistema para registrar las instancias de RQD-blender con Cuebot al momento de inicio:

    1. Haz clic en Opciones avanzadas de contenedor.
    2. Selecciona Ejecutar con privilegios.
    3. Haz clic en + Agregar variable, en Variable de entorno, y establece NAME como CUEBOT_HOSTNAME y VALUE como [CUEBOT_INTERNAL_IP_ADDRESS], que hace referencia a la dirección IP interna de la VM de Cuebot que aprovisionaste antes.

  9. Configura la cuenta de servicio como se indica a continuación:

    1. En la sección Cuenta de servicio, selecciona el [SERVICE_ACCOUNT_NAME] que creaste antes.
    2. Deja la configuración restante con sus valores predeterminados.
    3. Haz clic en Crear.

Crea un grupo de instancias administrado

Mediante la plantilla de instancias, crea un grupo de instancias administrado para determinar la ubicación de la VM, la cantidad de instancias y la configuración del ajuste de escala automático.

  1. En Cloud Console, ve a la página Grupos de instancias.

    IR A LA PÁGINA GRUPOS DE INSTANCIAS

  2. Haz clic en Crear grupo de instancias.

  3. Ingresa un nombre para el grupo de instancias administrado, por ejemplo, rqd-blender-mig.

  4. Selecciona Zona única, la región us-central1 y la zona us-central1-a.

  5. En Tipo de grupo, selecciona Grupo de instancias administrado.

  6. En Plantilla de instancias, selecciona tu plantilla de instancia, por ejemplo, rqd-blender.

  7. Establece el Ajuste de escala automático en Desactivado.

  8. En Cantidad de instancias, especifica 3.

  9. Haz clic en Crear.

Configura tu estación de trabajo local

Cuebot ahora se ejecuta en Google Cloud y está listo para administrar los hosts de renderización y la cola de trabajos. Si deseas habilitar la interfaz visual para enviar y administrar tareas, configura la estación de trabajo local a fin de que ejecute CueSubmit y CueGUI y, luego, conéctate desde el host local a Google Cloud.

Crea un directorio y establece permisos para el punto de activación del bucket

  • Crea un punto de activación para el bucket de Cloud Storage y establece sus permisos como lectura y escritura.

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

    Cuando se activan en la estación de trabajo local y en el host de renderización, estas rutas de acceso se resuelven en algo como /shots/robotdanceparty/sh_05/sh_05_lores.blend para tu archivo de escena de animación de entrada.

Activa el bucket del instructivo

  • Indica a gcsfuse que active el bucket del instructivo en tu máquina local como un sistema de archivos en la ruta de acceso /shots. La marca --implicit-dirs se usa para guiar la asignación de los objetos a los directorios.

    gcsfuse --implicit-dirs $YOUR_BUCKET /shots

    Configura el reenvío de SSH

Para ayudar a proteger la comunicación entre la estación de trabajo local y Google Cloud, en este instructivo se usa el reenvío de SSH. Mediante los siguientes comandos, se abre un puerto para reenviar llamadas entre las interfaces de OpenCue y Cuebot.

  1. Abre una shell nueva y guárdala para el proceso de SSH.

  2. Actualiza [YOUR_PROJECT_ID] y ejecuta los siguientes 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

Inicializa un entorno virtual

  1. Abre una ventana de shell nueva y guárdala para usar con CueGUI y CueSubmit.

  2. Para aislar el entorno antes de la instalación, ejecuta virtualenv:

    cd ~/OpenCue
virtualenv --python python2 venv

    Obtén más información sobre virtualenv.

  3. Instala el entorno virtual y, luego, instala las dependencias mediante pip.

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

    Puedes ejecutar cat requirements.txt para ver la lista de dependencias instaladas.

  4. Antes de iniciar CueGUI o CueSubmit, define las variables necesarias para la implementación.

    export OPENCUE_ROOT=~/OpenCue
export CUEBOT_HOSTS=localhost
export PYTHONPATH=$OPENCUE_ROOT/pyoutline/:$OPENCUE_ROOT/pycue/:$OPENCUE_ROOT/cuesubmit/:$OPENCUE_ROOT/cuegui/
    Variable de entorno Explicación
    CUEBOT_HOSTS=localhost Se refiere a cómo PyCue se conecta a la instancia de Cuebot. Se define como localhost cuando se usa el reenvío de SSH. Si usas una VPN o una interconexión dedicada, ingresa la dirección IP de Cuebot.
    PYTHONPATH=$OPENCUE_ROOT Define la ruta de acceso de Python a las bibliotecas de OpenCue.

Compila protocolos gRPC

OpenCue usa gRPC como su protocolo de comunicación para enviar mensajes entre el servidor y los clientes. Los servicios de gRPC se definen mediante búferes de protocolo en un archivo .proto independiente del lenguaje. Si deseas habilitar las bibliotecas de OpenCue para Python a fin de comunicarte mediante gRPC, haz lo siguiente:

  • Compila los archivos de definición .proto en archivos legibles de Python con los siguientes 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

Ejecuta las interfaces

En los próximos pasos, explorarás OpenCue, para lo cual enviarás un trabajo mediante CueSubmit, además de explorar la configuración de los trabajos y los hosts de renderización con CueGUI. Ambas herramientas usan el mismo entorno, por lo que debes ejecutar estos procesos en segundo plano en la shell del entorno virtual.

Ejecuta CueSubmit

  • En la shell del entorno de VM, ejecuta CueSubmit para que puedas enviar un trabajo:

    cd ~/OpenCue
python cuesubmit/cuesubmit &

Envía un trabajo

Mediante la interfaz de CueSubmit, ingresa las siguientes variables:

  1. Ingresa un Nombre de trabajo, por ejemplo, yourjobname.
  2. Ingresa una Toma, por ejemplo, sh_05.
  3. Ingresa un Nombre de capa, por ejemplo, render.

  4. En Comando a ejecutar, ingresa el siguiente comando:

    /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. En Especificaciones de marcos, ingresa 600-700.

  6. Establece Tipo de trabajo en Shell.

  7. Configura Servicios como shell.

  8. Deja el resto en sus valores predeterminados y haz clic en Enviar.

    Aparecerá una ventana que dice “Trabajo enviado a OpenCue”. Incluye un ID y un nombre de trabajo que te ayuden a realizar un seguimiento del trabajo mientras se renderiza.

    Opciones de línea de comandos para la renderización:

    Opción de línea de comandos Descripción
    /usr/local/blender/blender Ruta al ejecutable de blender.
    -b Procesador de marcas para ejecutar sin interfaz.
    -noaudio Procesador de marcas para no cargar bibliotecas de audio.
    /shots/robotdanceparty/sh_05/sh_05_lores.blend Ruta al archivo de escena que se procesará.
    -o /shots/renderimages/sh_05.lores.##### Define la ruta de salida, el nombre y el relleno del marco. ##### da como resultado que el marco 650 es sh_05.00650.jpg en el disco.
    -F JPEG Define el tipo de archivo de salida como JPEG.
    -f #IFRAME# Define el número del marco en el momento de la renderización y es específico de OpenCue. <Frame Spec> interactúa con esta variable, así que ingrésala tal como está aquí.

    Para obtener más información sobre la renderización de la línea de comandos de Blender, consulta la documentación de Blender.

    Ventana de envío de trabajo

    Variable Explicación
    Job Name (Nombre del trabajo) Una variable arbitraria que eliges al comienzo. La mayoría de las instalaciones siguen las convenciones de nombres para habilitar el seguimiento de trabajos de forma coherente.
    User Name (Nombre del usuario) Completado por OpenCue. Se registra como el usuario que inicia CueSubmit.
    Show (Mostrar) OpenCue crea un programa predeterminado llamado testing al comienzo. La mayoría de las instalaciones llaman a proyectos de películas individuales o programas comerciales en este contexto. La mejor manera de agregar y editar programas es mediante las herramientas de línea de comandos de CueAdmin.
    Shot (Toma) Un marco de una serie de marcos que se reproducen durante un período ininterrumpido. Una toma es el tiempo entre “Acción” y “Corte” en un escenario de filmación. Por lo general, se usa para tomas individuales en una secuencia o rotaciones de recursos durante la preproducción.
    Layer (Capa) Un comando individual dentro de un envío y un rango de marcos. En este ejemplo, ejecutarás una capa única, render, en tu trabajo.
    Command to Run (Comando a ejecutar) El comando en el que se ejecutará la capa. Aquí ejecutas una renderización de línea de comandos de Blender.
    Frame Spec (Especificaciones de marcos) Los marcos que se deben procesar. Se renderiza el marco 600-700 de la animación. Apunta al cuadro Frame Spec (Especificaciones de marcos) para ver más opciones, como pasos de marcos y entradas de marcos arbitrarias.
    Job Type (Tipo de trabajo) Se usa para definir el paquete de software que se usa en esta capa en un trabajo. El comando que definiste se interpreta como una secuencia de comandos de shell, por lo que debes ingresar Shell.
    Services (Servicios) Una lista de requisitos, como la memoria RAM mínima o un recurso definido por el usuario. Tu trabajo no necesita requisitos específicos además de la shell, por lo que debes seleccionar Shell.
    Submission Details (Detalles del envío) El resultado combinado de la configuración.

Descripción general de CueGUI

CueGUI es la interfaz central de una colección de módulos de IU, que se enfoca en diferentes aspectos de la granja de renderización. La siguiente es una lista de términos comunes, explicaciones y módulos relacionados que usas para supervisar tu trabajo y los hosts de renderización. Para obtener una descripción general visual de CueSubmit y CueGui, mira esta explicación en video.

Término Explicación Módulo CueGUI relacionado
trabajo Un envío individual a OpenCue. Supervisa trabajos
Atributos
capa Un comando individual dentro de un envío y un rango de marcos. En este ejemplo, ejecutarás una capa única, render, en tu trabajo. Supervisa detalles del trabajo
Atributos
host de renderización Un recurso de renderización individual que se usa para procesar una tarea. Supervisa detalles del trabajo
Supervisa hosts
LogView
Atributos
registros Los hosts de renderización escriben archivos de registro en el disco que se pueden analizar para obtener información, como solución de problemas o métricas de rendimiento. Supervisa detalles del trabajo
LogView
atributos Una lista de detalles sobre un envío o un recurso de OpenCue. En la ventana Atributo, se pueden cargar detalles sobre un trabajo, una capa o un host de renderización. Supervisa trabajos
Supervisa detalles del trabajo
Supervisa hosts
Atributos
etiqueta Un método de categorización que se puede agregar a un host o una capa para relacionarlos con determinados trabajos. Agrega las etiquetas de host a los recursos disponibles en cada host de renderización y las etiquetas de capas a los recursos necesarios a fin de procesar esa capa. Supervisa detalles del trabajo
Supervisa hosts
Atributos
etiquetas de capas Una etiqueta que define los requisitos necesarios para procesar una capa. Por ejemplo, una capa puede requerir una GPU, por lo que debes agregar una etiqueta de GPU a la capa. Supervisa detalles del trabajo
Supervisa hosts
Atributos
etiqueta de host Una etiqueta que define un recurso que tiene un host disponible. Por ejemplo, puedes agregar un recurso de GPU a un host que tenga una GPU instalada.
Un host selecciona una capa para renderizar si se cumplen estas etiquetas y una lista de requisitos de recursos.		 Supervisa detalles del trabajo
Supervisa hosts
Atributos

En este instructivo, no se aborda todo el funcionamiento de la interfaz y los conceptos de OpenCue. Si deseas obtener información más detallada, consulta la documentación.

Ejecuta CueGUI

  • En la misma shell de entorno virtual, abre CueGUI:

    cd ~/OpenCue
python cuegui/cuegui &

Abre la ventana Monitor Jobs (Supervisar trabajos)

  • Cuando se abra la ventana CueCommander, selecciona Vistas/Complementos > Cuetopia > Monitor Jobs (Supervisar trabajos).

Acerca de la ventana Monitor Jobs (Supervisar trabajos)

La ventana Monitor Jobs (Supervisar trabajos) funciona a nivel del trabajo, por lo que actúa como una vista general.

Ventana Monitor Jobs (Supervisar trabajos) en OpenCue

En la fila que contiene [Your Job], busca la siguiente información pertinente para este instructivo:

  • Job (Trabajo): El nombre de tu trabajo aparece aquí.
  • State (Estado): Este trabajo está In progress (En curso) porque se seleccionó y se está renderizando. Cuando se completa el trabajo, la sección State (Estado) cambia a Completo. Si el trabajo tuvo un problema, el State (Estado) cambia a Con errores, y se debe solucionar el problema. Para obtener más información sobre cómo solucionar problemas de renderización en OpenCue, consulta la documentación.
  • Done/Total (Listo/Total): Proporciona una descripción general del progreso del trabajo. En la imagen, se completaron 100 marcos de un trabajo de 101 marcos.
  • Running (En ejecución): Informa cuántos marcos se están procesando en los hosts de renderización. En esta imagen, solo se procesa 1 marco.
  • Progress (Progreso): Proporciona una descripción general visual del progreso del trabajo.

Explora la ventana Supervisar trabajos

  1. Supervisa el progreso de tu trabajo en la ventana Monitor Jobs (Supervisar trabajos). El trabajo debe estar In progress (En curso). Si dice Con errores, consulta la sección Soluciona problemas.
  2. Coloca el cursor sobre la palabra Progress (Curso). Aparecerá una ventana de descripción con información útil sobre la herramienta.
  3. Para explorar la interfaz, coloca el cursor sobre los demás íconos y encabezados de fila.
  4. Selecciona [Your Job].

Abre la ventana Supervisar detalles del trabajo

  1. Para abrir la ventana Supervisar detalles del trabajo, selecciona Vistas/Complementos > Cuetopia > Supervisar detalles del trabajo.
  2. En la ventana Monitor Jobs (Supervisar trabajos), haz doble clic en [Your Job] para cargar los datos en la ventana Supervisar detalles del trabajo.

Acerca de la ventana Supervisar detalles del trabajo

La ventana Supervisar detalles del trabajo funciona a nivel de la capa y contiene información detallada sobre tu trabajo.

Ventana Supervisar detalles del trabajo en OpenCue

El módulo Monitor Job Details (Supervisar detalles del trabajo) contiene dos ventanas:

  • El panel Layer (Capa). En la ventana con [Your Job] en la barra de título, verás el nombre de la capa.
  • Panel Información de la capa. En esta ventana, verás información relacionada con cada marco de la capa seleccionada.

Descripción general del panel Layer (Capa):

  • Layer (Capa): El trabajo tiene una capa, render (renderización). En caso de que el trabajo tenga varias capas, se enumerarán aquí y se podrán seleccionar de forma individual si haces doble clic.
  • Avg (Promedio): El promedio por tiempo de renderización de marcos de esta capa.
  • Tags (Etiquetas): Las etiquetas a nivel de capa se enumeran aquí. La configuración de las etiquetas no está dentro del alcance de este instructivo, pero esta es la ubicación para acceder a las etiquetas a nivel de capa.
  • Depend (Dependencia): Las dependencias de la capa se enumeran aquí. La administración de dependencias no está dentro del alcance de este instructivo, pero este marco es la ubicación para acceder a las dependencias a nivel de capa.

Descripción general del panel Información de la capa:

  • Botón Refresh (Actualizar): Si haces clic en este botón, se vuelve a cargar la interfaz con la información más reciente de la base de datos.
  • Order (Orden): El orden en el que se renderizan los marcos; se muestra aquí porque se pueden renderizar en un orden arbitrario. Por ejemplo, puedes renderizar cada 10 marcos y, luego, el resto de los marcos, o en orden inverso. Este orden se especifica en CueSubmit mediante las especificaciones de marcos cuando envías tu trabajo.
  • Frame (Marco): El número de marco de la escena que se renderizará.
  • Status (Estado): El estado del marco. En la imagen, estos marcos están en estado Succeeded (Completado).
  • Host: La dirección IP del host de renderización a la que se le asignó el marco.

Explora la ventana Supervisar detalles del trabajo

  1. Haz clic en Refresh (Actualizar) y examina el progreso del trabajo en la ventana Supervisar detalles del trabajo.
  2. Si colocas el cursor sobre la palabra Status (Estado) y aparecerá una ventana de descripción con información útil sobre la herramienta.
  3. Para explorar la interfaz, coloca el cursor sobre los demás íconos y encabezados de fila.

Abre la ventana LogView

  • Para abrir la ventana LogView, selecciona Vistas/Complementos > Otro > LogView.

Acerca de la ventana LogView

La ventana LogView proporciona una vista previa rápida de los registros de los marcos individuales. Esta vista puede ser útil si deseas recopilar información a fin de solucionar problemas, optimizar las renderizaciones o redimensionar las VM para pases de renderización futuros.

Ventana LogView en OpenCue

Un archivo de registro comienza con un encabezado que contiene datos específicos de OpenCue y continúa con la salida del software que procesa la imagen. En esta instancia, verás la configuración de OpenCue seguida de la salida del registro de Blender.

Explora la ventana LogView

  1. En la ventana Supervisar detalles del trabajo, selecciona un marco etiquetado como COMPLETADO en el panel Información de la capa para examinar los registros.
  2. Ten en cuenta el comando que se ejecuta.
  3. Anota el logDestination.

Puedes obtener más información sobre la ventana LogView en la documentación de OpenCue.

Abre la ventana Monitor Hosts (Supervisar hosts)

  • Para abrir la ventana Monitor Host (Supervisar hosts), selecciona Vistas/Complementos > CueCommander > Monitor Hosts (Supervisar hosts).

Acerca de la ventana Monitor Hosts (Supervisar hosts)

La ventana Monitor Hosts (Supervisar hosts) proporciona información sobre hosts de renderización individuales y es una interfaz para agregar o quitar recursos mediante etiquetas.

Ventana Monitor Hosts (Supervisar hosts) en OpenCue

La siguiente información es pertinente en este instructivo:

  • Casilla Auto-refresh (Actualización automática): Selecciona esta casilla para volver a cargar la ventana Monitor Hosts (Supervisar hosts).
  • Cuadro Refresh (Actualizar): Haz clic en este botón para volver a cargar la ventana Monitor Hosts (Supervisar hosts).
  • Dirección IP: La dirección IP permite un fácil seguimiento de las VM entre OpenCue y Google Cloud.
  • Load % (% carga): El promedio de carga en el host, un buen indicador del uso de la máquina.
  • Mem (Memoria): Asignación de memoria del host.
  • Tags (Etiquetas): Recursos registrados en el host.

Explora la ventana Supervisar hosts

  1. Haz clic en Refresh (Actualizar) o selecciona la casilla de verificación Auto-refresh (Actualización automática).
  2. Para seleccionar un host de renderización, haz clic en la Dirección IP.

  3. Haz clic con el botón derecho sobre el host de renderización para ver más opciones, como Borrar host o Agregar o quitar etiquetas.

    Para obtener más información sobre la administración de recursos con etiquetas, consulta la documentación.

  4. Haz doble clic en un host para verificar sus atributos.

  5. Fíjate en que asignación está configurada como local.general.

  6. Fíjate en las etiquetas, que son general, y en la dirección IP del host.

Abre la ventana de Atributos

  • Selecciona Vistas/Complementos > Otros > Atributos.

Acerca de la ventana Attributes (Atributos)

La ventana Attributes (Atributos) proporciona una lista de detalles sobre un trabajo, una capa o un host de renderización. A continuación, se muestra un ejemplo de cada uno.

Ventana Atributos de OpenCue

Cada ventana contiene información relacionada con el host, la capa o el trabajo. La etiqueta facility local (instalación local) en Job Attributes (Atributos del trabajo) y la etiqueta general en Layer Attributes (Atributos de la capa) son indicadores clave de los requisitos de este envío. Los marcos de este trabajo solo seleccionan los hosts de renderización que tienen asignadas estas etiquetas. Puedes ver que se asignan en Host Attributes (Atributos del host) si observas las líneas alloc (asignación) y tags (etiquetas).

Explora la ventana Attributes (Atributos)

  1. En la ventana Monitor Hosts (Supervisar hosts), haz clic en la dirección IP de un host de renderización para cargar sus atributos.
  2. En la ventana Attributes (Atributos), verifica la configuración de alloc (asignación) y tags (etiquetas).
  3. En la ventana Supervisar detalles del trabajo, haz clic en un marco Completado para cargar sus atributos.
  4. En la ventana Attributes (Atributos), explora la configuración de minMemory (memoria mínima) y tags (etiquetas).
  5. En la ventana Monitor Jobs (Supervisar trabajos), haz clic en un trabajo.
  6. En la ventana Attributes (Atributos), explora la configuración de facility (instalación) y minCores (núcleos mínimos).

Para obtener una explicación más detallada, consulta Referencia de CueGUI.

Verifica los marcos renderizados

Hay varias maneras de verificar los marcos mientras se renderizan o de copiarlos de forma local después de completar la renderización. La instalación de las herramientas de vista previa de animación está fuera del alcance de este instructivo, pero puedes usar Cloud Console si deseas obtener vistas previas de los marcos individuales o descargarlos de forma local para verlos en la aplicación de visualización de imágenes que prefieras.

  1. En Cloud Console, visualiza una lista de objetos en un bucket o imágenes de vista previa en un navegador de la siguiente manera:

    IR A LA PÁGINA DE CLOUD STORAGE

  2. Haz clic en [YOUR_BUCKET_NAME] y, luego, en renderimages para ver una lista de marcos.

  3. Haz clic en una imagen, por ejemplo, sh_05_lores.00650.jpg, para obtener una vista previa de la ventana del navegador.

  4. Usa la shell local para ver una lista de imágenes en el directorio de salida:

      ls /shots/renderimages

    También puedes copiar archivos de forma local o abrirlos en la herramienta de visualización que elijas.

  5. Usa gsutil para enumerar objetos en un depósito:

    gsutil ls gs://[YOUR_BUCKET_NAME]/renderimages

  6. Usa gsutil para copiar todos los objetos en tu depósito a un directorio local, [LOCAL_DIRECTORY].

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

Finaliza el trabajo

Si tu renderización aún se está procesando, puedes optar por completarla y explorar más OpenCue, o puedes detener la renderización si la finalizas en la ventana Monitor Jobs (Supervisar trabajos).

Para finalizar el trabajo en OpenCue, sigue estos pasos:

  1. Abre la ventana Supervisar trabajos.
  2. Selecciona [Your Job] y haz clic en el botón Finalizar trabajo.
  3. En una ventana emergente, se te preguntará: “¿Estás seguro de que deseas finalizar estos trabajos?”

  4. Haz clic en Aceptar para finalizar el trabajo.

Explora las opciones para tu granja de renderización (opcional)

Para mantener este instructivo dentro de un límite de 8 CPU virtuales en total, implementaste pocos hosts de renderización de tamaño modesto para la tarea de renderización. Supongamos que tu objetivo es terminar el trabajo con rapidez o crear una animación que esté lista para la pantalla grande. Si es así, puedes implementar una mayor cantidad de recursos con más CPU si modificas tu plantilla de instancias existente para usar una CPU virtual n1-highcpu-4 o superior y creas un grupo de instancias administrado a fin de controlar la cantidad total de hosts de renderización disponibles para el trabajo.

Has renderizado el siguiente archivo de escena de baja resolución en VM n1-standard-2, en alrededor de 1 minuto por marco.

  • Archivo de escena:

    gs://[YOUR_BUCKET_NAME]/robotdanceparty/sh_05/sh_05_lores.blend

  • Imagen resultante:

    Imagen de baja resolución de una fiesta de robots

    El depósito del instructivo contiene un archivo de escena de resolución más alta que, cuando se procesa, crea imágenes similares a estas en unos 8 minutos mediante una VM n1-highcpu-4.

    Si deseas probar otras opciones en OpenCue, actualiza tu comando CueSubmit para hacer referencia a este archivo de resolución más alta.

  • Archivo de escena:

    gs://[YOUR_BUCKET_NAME]/robotdanceparty/sh_05/sh_05.blend

  • Imagen resultante:

    Resolución un poco más alta de la misma imagen de robots

Solicita un cambio en la cuota (opcional)

Si deseas aumentar la cantidad de hosts de renderización o usar VM más grandes, es posible que debas aumentar la cuota de tu proyecto.

  1. Ve a la página Cuotas.

    IR A LA PÁGINA CUOTAS

  2. En la página Cuotas, selecciona las cuotas que deseas cambiar.

  3. Haz clic en el botón Editar cuotas en la parte superior de la página.

  4. Marca la casilla del servicio que deseas editar.

  5. Ingresa tu nombre, correo electrónico y número de teléfono, y haz clic en Siguiente.

  6. Ingresa tu solicitud de aumento de cuota y haz clic en Siguiente.

  7. Envía la solicitud.

Soluciona problemas

Problema: Problemas con el proceso de compilación de Docker.

Solución: Intenta compilar el Dockerfile con la marca --no-cache, lo que obligará a Docker a usar datos recientes en todos los pasos. Para obtener más información sobre las opciones de compilación de Docker, consulta la documentación.

Problema: Error Connect Failed en la shell cuando se inicia CueSubmit o CueGUI. Por lo general, el error es similar al siguiente:

Encountered a server error. StatusCode.UNAVAILABLE : Connect Failed

Solución: Asegúrate de que el túnel SSH funcione y, luego, reinicia CueSubmit o CueGUI.

  1. Ejecuta el comando de estado del proceso en una shell local para asegurarte de que el túnel SSH esté abierto:

    ps aux | grep ssh.

    Se muestra una lista de procesos. Uno de ellos debería tener un resultado similar a este, con tu [USER_NAME], [PROJECT_NAME] y 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. Asegúrate de que [USER_NAME], [PROJECT_NAME], --zone y el nombre (cuebot) sean correctos para tu implementación.

  3. Debes detener el proceso de SSH y rehacer los pasos de la sección “Configura el reenvío de SSH” de este documento para abrir un túnel SSH nuevo.

Problema: CueSubmit o CueGUI se abren, pero muestran errores en su shell de inicio.

Solución: Conéctate a tu instancia de Cloud SQL y asegúrate de que se haya propagado con los datos del esquema y del ejemplo. Si no ves el resultado deseado, vuelve a importar los archivos en la sección Crea una base de datos de Cloud SQL (consulta el paso “Importa el esquema de base de datos y los datos de demostración”).

  1. En Cloud Console, ve a Cloud Shell y ejecuta el siguiente comando para actualizar la instancia de Cloud SQL. Reemplaza [CLOUD_SQL_INSTANCE_ID] por el nombre de tu instancia.

    gcloud sql connect [CLOUD_SQL_INSTANCE_ID] --user=postgres

  2. Cuando se te solicite, actualiza [DATABASEPASSWORD] y presiona Intro:

    [DATABASEPASSWORD]

  3. Ingresa el siguiente comando y presiona Intro:

    \c cuebot

  4. Vuelve a ingresar la contraseña cuando se te solicite y presiona Intro:

    [DATABASEPASSWORD]

  5. Ingresa el siguiente comando:

    \d+

    Espera un resultado similar al siguiente:

    >
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: Errores en la shell de CueSubmit o CueGUI, por lo que no se ejecutan ninguna de estas dos herramientas.

Solución: Asegúrate de que la conexión entre CueBot y tu base de datos funcione. Para ello, verifica las siguientes variables:

  1. Asegúrate de haber ingresado [RESERVED_STATIC_IP_ADDRESS] de forma correcta en el paso “Red” de la sección Crea una instancia de Cloud SQL.
  2. Asegúrate de haber ingresado [CLOUD_SQL_IP_ADDRESS] y [DATABASEPASSWORD] de forma correcta en el paso “Argumentos del comando” de la sección Configura y aprovisiona la VM de Cuebot.
  3. Asegúrate de haber ingresado la dirección IP externa reservada de forma correcta en el paso “Establece la configuración de red” de la sección Configura y aprovisiona la VM de Cuebot.

Problema: Se muestra un trabajo iniciado en OpenCue, pero no se detecta en los hosts de renderización.

Solución: Asegúrate de que las etiquetas Instalación del trabajo y Capa del trabajo coincidan con las etiquetas asignadas del Host de renderización y que se cumplan los requisitos mínimos de los recursos. Para obtener más información, consulta los documentos de Soluciona problemas de renderización y Soluciona problemas de implementación de OpenCue.

Problema: Los hosts de renderización no son visibles en CueGui.

Solución: Varios problemas pueden provocar que los hosts no sean visibles. Lo más probable es que la dirección IP interna de Cuebot se haya ingresado de forma incorrecta cuando se implementó la plantilla de instancias del host de renderización. Para obtener más información, consulta la documentación Soluciona problemas de implementación.

Realice una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?