Créer une ferme de rendu avec OpenCue dans GCP

Danse du robot

Ce tutoriel explique comment déployer le système de gestion de rendu OpenCue sur des machines virtuelles Linux (VM) à l'aide de Google Cloud. Prévoyez trois à quatre heures pour suivre l'ensemble du tutoriel.

Les outils de gestion de rendu sont utilisés dans la production d'effets visuels et d'animation. Ils servent à décomposer des tâches complexes en tâches individuelles et à répartir ces processus sur un large éventail de ressources de calcul. Ces outils permettent de gérer des tâches, parmi lesquelles les rendus 3D, la composition 2D, le transcodage de données d'un format à un autre et la vérification des éléments importés et exportés des bases de données. Les outils sont souvent utilisés pour associer les étapes d'une tâche et les dépendances. Pour les installations plus importantes, un système de gestion de rendu permet de gérer des milliers de tâches simultanées. Il fournit également une interface permettant d'allouer des ressources à chaque étape d'une tâche, de gérer les journaux, de résoudre les problèmes liés aux outils et de gérer les ressources.

Google s'est associé à Sony Pictures Imageworks pour lancer OpenCue, un système de gestion de rendu Open Source éprouvé en termes de production qui fonctionne sous Linux et macOS. OpenCue a permis de créer des fermes de rendu sur site et de réaliser des déploiements hybrides à très grande échelle en exploitant les ressources de plusieurs fournisseurs cloud.

Ce tutoriel est destiné aux administrateurs informatiques et aux directeurs techniques de pipeline qui connaissent les outils et les concepts répertoriés ci-dessous. Si vous ne maîtrisez pas tous les concepts de cette liste, nous avons indiqué des ressources supplémentaires, le cas échéant.

  • Les principes de fonctionnement de la gestion de rendu distribuée
  • Git et GitHub
  • Docker pour la création et l'exécution de conteneurs
  • Le script Bash pour la modification de scripts et l'exécution de ressources
  • La configuration de Python et la modification de scripts
  • Les outils et les concepts de base de la gestion des ressources Google Cloud, y compris Cloud SQL, Compute Engine, Cloud Storage et Container Registry

Les outils de gestion de rendu couvrant plusieurs cas d'utilisation et orchestrant un large éventail de ressources, il existe de nombreuses façons de configurer une ferme de rendu. Ce tutoriel s'articule autour d'une seule configuration et vous permet de démarrer avec OpenCue aussi rapidement que possible. Pour créer une architecture plus optimale pour votre ferme de rendu, vous devrez peut-être modifier des étapes, établir le profil de performances de votre workflow ou échanger des types de ressources Google Cloud. Pour en savoir plus sur les options de configuration et de gestion d'une ferme de rendu sur Google Cloud, consultez la page Créer une ferme de rendu hybride. Pour obtenir plus d'informations sur la sécurisation de vos données, consultez la page Sécuriser les charges de travail de rendu.

Objectifs

  • Installer et configurer les modules OpenCue à l'aide de Docker et Python
  • Créer une base de données OpenCue et la remplir avec un schéma et des exemples de données
  • Créer des ressources Cloud Storage et les remplir avec les fichiers de scène d'animation du tutoriel
  • Configurer et créer des images Docker en local, les stocker dans Container Registry et démarrer les ressources Compute Engine à l'aide de conteneurs
  • Créer des modèles d'instance et des groupes d'instances gérés dans le but d'obtenir un scaling efficace des ressources de calcul
  • Configurer un poste de travail pour exécuter l'interface d'OpenCue sur site
  • Effectuer le rendu d'une séquence d'animation et explorer la gestion des tâches à l'aide de l'interface d'OpenCue

Coûts

Vous pouvez utiliser le simulateur de coût pour générer une estimation des coûts en fonction de l'utilisation prévue.

Ce tutoriel couvre chaque étape de la création d'une ferme de rendu fonctionnelle en tenant compte de contraintes strictes liées au nombre et au dimensionnement des machines. Afin de respecter les consignes de tarification de la version gratuite de Google Cloud au cours de ce tutoriel, vous allez effectuer le rendu d'une animation avec une résolution et des taux d'échantillonnage faibles sur quelques VM dotées de deux processeurs virtuels.

Le coût des ressources qui composent ce tutoriel, s'il est utilisé pendant quatre heures au total, s'élève à 3,27 $.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder à la page de sélection du projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API Container Registry and Compute Engine.

    Activer les API

  5. Assurez-vous que les éléments suivants sont installés sur votre ordinateur local :
    • Docker : ce tutoriel utilise la version 18.09.0 de Docker Engine.
    • Python : ce tutoriel utilise la version 2.7.10.
    • Pip : ce tutoriel utilise la version 19.0.
    • Virtualenv : ce tutoriel utilise la version 16.2.0.
    • gcsfuse : ce tutoriel utilise la version 0.23.0.
    • La dernière version du SDK Cloud : ce tutoriel nécessite que vous installiez le SDK Cloud pour pouvoir utiliser les outils de ligne de commande gcloud et gsutil. Vous devez exécuter les outils gcloud et gsutil dans un terminal de votre poste de travail local.

Présentation d'OpenCue

L'interface d'OpenCue utilise divers modules et commandes, ainsi que plusieurs concepts et termes uniques. Les outils et techniques ci-dessous permettent de déployer une ferme de rendu hybride de base. Pour obtenir des informations sur des sujets plus avancés et sur les différentes options de déploiement, consultez la documentation OpenCue.

  • Cuebot : outil de planification d'OpenCue. Cuebot gère la distribution des tâches et les ressources de rendu. Il communique également avec la base de données. Il est possible d'accéder à Cuebot à l'aide de Python et de Bash via une interface de ligne de commande (CLI). Une interface visuelle, décrite plus loin dans le tutoriel, est également incluse en tant que module séparé. Dans cet exemple, vous exécutez Cuebot sur une VM Google Cloud. Vous pouvez également l'exécuter localement pour les déploiements sur site. Pour ce qui est des déploiements plus importants ou hybrides, vous pouvez utiliser plusieurs instances Cuebot pour une haute disponibilité.
  • Base de données : Cuebot interagit avec un serveur de base de données PostgreSQL pour stocker l'état de l'application. Même dans un déploiement comprenant plusieurs Cuebots, une seule base de données est partagée entre les instances. Dans ce tutoriel, nous utilisons une instance Cloud SQL pour simplifier le déploiement.
  • CueGUI : interface visuelle pour interagir avec Cuebot. CueGUI permet de surveiller et de gérer les paramètres des tâches et des hôtes de rendu. Dans ce tutoriel, vous exécutez Cuebot dans le cloud et CueGUI sur votre ordinateur local.
  • Hôtes de rendu : ressources de rendu individuelles utilisées pour le traitement de tâches individuelles. Ces hôtes peuvent se trouver sur site, dans le cloud, ou les deux. Dans ce tutoriel, vous utilisez un groupe d'instances géré de VM dans Google Cloud en tant qu'hôtes de rendu.
  • RQD : daemon des files d'attente de rendu qui s'exécute sur des hôtes de rendu individuels et interagit avec Cuebot pour envoyer et recevoir des instructions sur les commandes à exécuter.
  • CueSubmit : interface utilisateur graphique (IUG) pour la configuration et le démarrage des tâches. Vous pouvez exécuter ce programme Python en tant qu'IUG autonome ou en tant que plug-in dans un logiciel tiers. OpenCue comprend un plug-in Maya (testé avec les versions 2017 et ultérieures) et un plug-in Nuke (testé avec la version 11). Le dépôt OpenCue inclut du code que vous pouvez modifier afin de créer vos propres plug-ins pour d'autres outils tiers ou pour personnaliser votre pipeline.
  • PyCue : collection de bibliothèques Python permettant d'interagir avec Cuebot. Ces bibliothèques peuvent servir à créer plus d'outils ou à communiquer avec Cuebot sur la ligne de commande plutôt que via une IUG.
  • PyOutline : bibliothèque Python pour la création de soumissions de tâches OpenCue. PyOutline permet de créer une spécification de tâches et de définir des dépendances. Dans ce tutoriel, vous n'interagissez pas directement avec ce module, car CueSubmit l'utilise en arrière-plan.
  • CueAdmin : outil de ligne de commande se servant de l'API PyCue Python pour administrer OpenCue.

Architecture du programme OpenCue

Le schéma d'architecture ci-dessous illustre comment les modules OpenCue se connectent et communiquent entre eux.

Schéma d'architecture OpenCue

Ressources Google Cloud utilisées dans ce tutoriel

Le schéma d'architecture suivant présente les ressources Google Cloud nécessaires pour suivre ce tutoriel.

Ressources Google Cloud nécessaires pour suivre ce tutoriel

Télécharger le dépôt OpenCue

Le dépôt officiel d'OpenCue est hébergé sur GitHub.

  • La commande suivante vous permet d'accéder à l'espace de travail et au dépôt que vous utiliserez pour ce tutoriel, et de télécharger le dépôt OpenCue :

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

Créer un bucket Cloud Storage et le remplir avec des fichiers du tutoriel

Ce tutoriel utilise un bucket Cloud Storage pour stocker tous les fichiers de scène d'animation et autres dépendances de fichier d'entrée, ainsi que les résultats de rendu final et les fichiers journaux de l'hôte de rendu.

Plus tard, vous allez installer et utiliser Cloud Storage FUSE (gcsfuse). Il s'agit d'un adaptateur FUSE Open Source qui permet d'installer des buckets Cloud Storage en tant que systèmes de fichiers sur vos hôtes de rendu Linux et sur votre ordinateur local. gcsfuse fournit une option de stockage économique et efficace pour ce workflow. Toutefois, vous pouvez améliorer considérablement les performances de certaines tâches en associant des tâches individuelles à un profil de stockage optimisé spécifiquement pour leurs besoins. Google Cloud propose de nombreuses options de stockage. Cependant, nous ne nous attarderons pas sur les avantages et les inconvénients pour chaque workflow dans ce document. Pour en savoir plus sur les options de stockage, consultez la page Créer une ferme de rendu hybride. Vous pouvez également vous adresser à un représentant Google Cloud pour choisir une option de stockage adaptée à vos besoins.

Créer un bucket Cloud Storage

Avant de créer un bucket, assurez-vous d'être dans le bon projet :

  • Créez un bucket Cloud Storage [YOUR_BUCKET_NAME] pour stocker les données du tutoriel.

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

    La commande gsutil fait référence à la création de ressources dans la région us-central1.

Synchroniser les données du tutoriel avec votre bucket

Le bucket Cloud Storage contient environ 950 Mo de données pour ce tutoriel. Utilisez gsutil rsync pour synchroniser les données du bucket source vers un bucket de destination sans avoir à télécharger ces données sur votre ordinateur local. L'option -r copie les sous-répertoires récursifs. Quant à l'option -m, elle se synchronise en parallèle et s'avère utile pour traiter de multiples fichiers.

  1. Créez une variable d'environnement pour le nom de votre bucket Cloud Storage :

    export YOUR_BUCKET=[YOUR_BUCKET_NAME]
    
  2. Synchronisez les exemples de données avec le bucket :

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

Importer le schéma de base de données et les exemples de données

Importez le schéma de base de données et les exemples de données de démonstration pour remplir la table de base de données :

  1. Copiez les fichiers V1__Initial_schema.sql, V2__Add_limit_table.sql et V3__increase_show_length.sql du répertoire local OpenCue dans le bucket Cloud Storage du tutoriel :

    gsutil cp ~/OpenCue/cuebot/src/main/resources/conf/ddl/postgres/migrations/* gs://$YOUR_BUCKET/database/
    
  2. Copiez le fichier demo_data.sql du répertoire local OpenCue dans le bucket Cloud Storage du tutoriel :

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

Déployer la base de données

Le module Cuebot d'OpenCue stocke les données d'état du programme dans une base de données PostgreSQL. Dans le cadre de ce tutoriel, vous devez d'abord réserver une adresse IP externe pour la VM faisant office de Cuebot. Ensuite, vous devez provisionner et configurer une instance Cloud SQL, configurer la connectivité réseau en ajoutant l'adresse IP de Cuebot à la liste blanche, puis remplir la base de données avec un schéma et des données de démonstration.

Réserver une adresse IP externe statique pour Cuebot

Avant de créer la base de données ou la VM pour Cuebot, réservez une adresse IP externe statique pour que la VM Cuebot soit utilisée pour les communications réseau entre ces deux ressources :

  1. Accédez à la page Réserver une adresse statique dans Cloud Console.

    Accéder à la page "Réserver une adresse statique"

  2. Choisissez un nom pour la nouvelle adresse (par exemple, cuebotstaticip).

  3. Pour Niveau de service réseau, spécifiez Premium.

  4. Dans le champ Version IP, spécifiez IPv4.

  5. Pour Type, choisissez Régional.

  6. Sélectionnez la région us-central1.

  7. Laissez le champ Associé à défini sur Aucun.

  8. Cliquez sur Réserver pour réserver l'adresse IP.

Une fois la ressource créée, vous êtes redirigé vers la page Adresses IP externes. Vous référencez cette adresse sous [RESERVED_STATIC_IP_ADDRESS].

Créer une instance Cloud SQL

Il existe de nombreuses options permettant de créer une base de données PostgreSQL. Ce tutoriel utilise Cloud SQL, qui offre une configuration facile et une base de données entièrement gérée sur Google Cloud. Cette instance utilise des disques SSD pour des lectures et des écritures rapides, mais sa capacité de stockage initiale est faible, avec un seul processeur virtuel et 3,75 Go de RAM. En cas de scaling d'OpenCue pour des déploiements plus importants, cette ressource est celle que vous souhaiterez développer en premier. Sachez que Cloud SQL peut évoluer afin de s'adapter au déploiement.

  1. Accédez à la page "Instances Cloud SQL" dans Cloud Console.

    Accéder à la page "Instances Cloud SQL"

  2. Sélectionnez le projet, puis cliquez sur Continuer.

  3. Cliquez sur Créer une instance.

  4. Cliquez sur PostgreSQL.

  5. Saisissez un ID d'instance (par exemple, opencuedatabase).

  6. Indiquez le mot de passe de l'utilisateur postgres. Lors de la création de Cuebot, vous référencez ce mot de passe sous [DATABASEPASSWORD].

  7. Définissez la région sur us-central1 et la zone sur us-central1-a.

  8. Configurez les options de connectivité :

    1. Cliquez sur Afficher les options de configuration, puis sélectionnez Connectivité.
    2. Sélectionnez Adresse IP publique, puis Ajouter un réseau.
    3. Dans le champ Réseau, saisissez votre adresse [RESERVED_STATIC_IP_ADDRESS].
    4. Cliquez sur Créer.

    Vous revenez à la liste des instances. Votre nouvelle instance est grisée pendant les phases d'initialisation et de démarrage.

Créer une base de données Cloud SQL

  1. Dans la page Détails de l'instance de votre ressource Cloud SQL, sélectionnez Bases de données.
  2. Sélectionnez Créer une base de données.
  3. Définissez le champ Nom de la base de données sur cuebot.
  4. Cliquez sur Créer.
  5. Importez le schéma de base de données et les données de démonstration de la manière suivante :

    1. Sélectionnez Importer.
    2. Dans la ligne de fichier Cloud Storage, cliquez sur Parcourir.
    3. Accédez au bucket de stockage [YOUR_BUCKET_NAME] que vous avez importé, puis importez le schéma de votre base de données en sélectionnant le fichier suivant :

      gs://[YOUR_BUCKET_NAME]/database/V1__Initial_schema.sql
      
    4. Définissez le champ Format d'importation sur SQL.

    5. Dans le champ Base de données, sélectionnez cuebot.

    6. Sélectionnez Afficher les options avancées.

    7. Dans le champ Utilisateur, sélectionnez l'utilisateur postgres.

    8. Cliquez sur Importer.

    Une fois l'importation terminée, vous êtes redirigé vers la page Détails de l'instance Cloud SQL.

    Répétez les étapes précédentes pour importer les données de démonstration à partir des fichiers suivants :

    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
    

Une fois les importations terminées, vous êtes redirigé vers la page Détails de l'instance Cloud SQL. Retenez l'adresse IP de Cloud SQL, que l'on nommera plus tard [CLOUD_SQL_IP_ADDRESS], car vous en aurez besoin lors de la configuration de Cuebot.

Préparer une image Docker Cuebot pour le déploiement

Dans ce tutoriel, Cuebot est déployé en tant que conteneur Docker sur une seule VM Compute Engine. Commencez par créer une image Docker Cuebot localement à partir du dépôt OpenCue, puis envoyez-la à Container Registry. Container Registry est un dépôt d'images Docker privé sur Google Cloud qui peut vous servir à stocker les images Docker tout au long de ce tutoriel. Pour en savoir plus sur ce workflow, consultez la documentation Compute Engine.

Créer l'image

  1. Assurez-vous de vous trouver au niveau racine du dépôt OpenCue :

    cd ~/OpenCue
    
  2. Créez une variable nommée TAG_NAME et une autre pour PROJECT_NAME. Créez ensuite une image à l'aide de Docker avec ce tag à des fins de suivi. En incluant gcr.io/[PROJECT_NAME] à l'étape de création, vous activez l'ajout de tags pour une synchronisation ultérieure avec 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 .
    

Synchroniser l'image avec Container Registry

Autorisez l'outil gcloud pour permettre à Docker d'importer des images dans Container Registry. Synchronisez ensuite l'image Docker Cuebot avec Container Registry.

  1. Exécutez la commande suivante pour autoriser l'outil gcloud et la synchronisation Docker :

    gcloud auth configure-docker
    
  2. Lorsque l'invite suivante s'affiche, saisissez y, puis appuyez sur Entrée.

    Do you want to continue (Y/n)?
  3. Transférez l'image Docker Cuebot depuis le dépôt local vers Container Registry :

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

Cette importation prend quelques instants à la fin de la synchronisation.

Configurer et provisionner la VM Cuebot

La console vous permet de provisionner une VM à l'aide d'un système d'exploitation optimisé pour le conteneur (Container-Optimized OS), de configurer les paramètres du conteneur, de créer une connexion à la base de données et d'associer l'adresse IP statique externe réservée.

  1. Accédez à la page Instances de VM.

    ACCÉDER À LA PAGE INSTANCES DE VM

  2. Cliquez sur le bouton Créer une instance pour créer une instance.

  3. Nommez l'instance cuebot.

  4. Définissez la région sur us-central1 et la zone sur us-central1-a.

  5. Dans le champ Type de machine, sélectionnez Personnaliser et configurez un type de machine avec un processeur virtuel et 6,5 Go de mémoire.

  6. Configurez les paramètres du Conteneur de la manière suivante :

    1. Dans la section Conteneur, sélectionnez Déployer l'image du conteneur.
    2. Mettez à jour [PROJECT_NAME] et spécifiez l'image de conteneur suivante.

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

    3. Développez les Options avancées des conteneurs.

    4. Sous Arguments de la commande, ajoutez trois arguments en cliquant sur Ajouter un argument à trois reprises.

    5. Saisissez les arguments de commande suivants en remplaçant [CLOUD_SQL_IP_ADDRESS] et [DATABASEPASSWORD] par vos valeurs.

      --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]
      

      Où :

      Argument de commande Explication et entrées requises
      --datasource.cue-data-source.jdbc-url=jdbc:postgresql://[CLOUD_SQL_IP_ADDRESS]/cuebot Active la communication depuis Cuebot vers la base de données. L'entrée est [CLOUD_SQL_IP_ADDRESS]/[DATABASE_NAME]. Vous avez renseigné cuebot pour le nom de la base de données lors d'une étape précédente. Il se retrouve donc ici.
      --datasource.cue-data-source.username=postgres Cuebot nécessite le nom d'utilisateur de la base de données lors de la connexion. Lors de la configuration, vous avez utilisé le nom d'utilisateur par défaut, postgres, qui se retrouve donc ici. Pour la production, vous devez suivre les bonnes pratiques de sécurité et créer un utilisateur avec des droits spécifiques.
      --datasource.cue-data-source.password=[DATABASEPASSWORD] Cuebot nécessite le mot de passe de la base de données au moment de la connexion. Saisissez le mot de passe [DATABASEPASSWORD] ici.
  7. Configurez les paramètres réseau en procédant comme suit :

    1. Sous Mise en réseau, sélectionnez Interfaces réseau.
    2. Cliquez sur Adresse IP externe, puis sélectionnez l'adresse IP externe réservée que vous avez créée précédemment pour Cuebot : cuebotstaticip.
    3. Cliquez sur OK.
    4. Conservez les valeurs par défaut pour les autres paramètres.
    5. Cliquez sur Créer.

Le démarrage de la VM prend quelques instants. Notez l'adresse IP interne. Vous en aurez besoin lors de la création du modèle d'instance. L'adresse sera désignée plus tard par le nom [CUEBOT_INTERNAL_IP_ADDRESS].

Créer des hôtes de rendu

Les hôtes de rendu sont constitués de VM s'exécutant en tant que groupe d'instances géré (MIG, Managed Instance Group), ce qui permet de contrôler l'emplacement et le scaling de vos ressources. Le groupe d'instances géré utilise un modèle d'instance pour déterminer le type de machine, activer la gestion des comptes de service, déployer une image de conteneur, et configurer les paramètres de conteneur et les variables d'environnement.

Les images de conteneur permettent de configurer de nombreux packages logiciels et dépendances nécessaires à l'exécution des tâches de rendu de ce tutoriel. Pour configurer les images de conteneur pour votre projet, utilisez Docker pour créer une image de base de l'hôte de rendu et la stocker dans un dépôt local. Vous pouvez ensuite personnaliser cette image de base en ajoutant un logiciel spécifique à une tâche et des paramètres Google Cloud depuis le dépôt du tutoriel avant de l'envoyer à Container Registry.

Créer l'image de base de l'hôte de rendu

  • Dans votre interface système locale, créez l'image de base de l'hôte de rendu.

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

Configurer l'image Blender

Le fichier Dockerfile et les scripts associés nécessaires à la création de l'image Blender de l'hôte de rendu se trouvent dans le dépôt du tutoriel. Dans cette section, vous allez télécharger le dépôt et mettre à jour quelques paramètres dans le but de le rendre opérationnel pour votre projet.

  1. Accédez au répertoire et à l'espace de travail que vous utilisez pour ce tutoriel, puis téléchargez le dépôt du tutoriel.

    cd ~
    git clone https://github.com/GoogleCloudPlatform/python-opencue-demo.git
    
  2. Une fois l'hôte de rendu démarré, le script rqd_startup.sh de ce dépôt appelle gcsfuse pour installer le bucket du tutoriel en tant que système de fichiers sur le chemin d'accès /shots. Ouvrez le fichier Dockerfile dans votre éditeur de texte et mettez à jour la variable GCS_FUSE_BUCKET pour qu'elle pointe vers le bucket du tutoriel :

    1. Dans une interface système, copiez le fichier suivant à la racine du dépôt.

      cp ~/python-opencue-demo/third_party/Dockerfile ~/python-opencue-demo/Dockerfile
      
    2. Dans l'éditeur de texte de votre choix, modifiez le fichier de la manière suivante :

      ~/python-opencue-demo/Dockerfile
      
    3. Mettez à jour [YOUR_BUCKET_NAME] avec le nom de votre bucket dans la ligne suivante :

      ENV GCS_FUSE_BUCKET [YOUR_BUCKET_NAME]
      
    4. Enregistrez, puis quittez l'éditeur de texte.

Créer l'image et l'envoyer à Container Registry

  1. Créez l'image comme suit :

    cd ~/python-opencue-demo
    docker build -t gcr.io/$PROJECT_NAME/opencue/rqd-blender:$TAG_NAME .
    
  2. Une fois la création terminée, transférez l'image vers Container Registry.

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

Déployer des hôtes de rendu

Vos hôtes de rendu doivent disposer d'autorisations de lecture et d'écriture lors du rendu. Pour leur accorder l'accès, créez un compte de service en appliquant le principe de sécurité de moindre privilège. Utilisez ce compte pour l'identité et l'accès à l'API au moment du provisionnement de vos VM.

Créer un compte de service

  1. Dans Cloud Console, accédez à la page Comptes de service.

    Accéder à la page "Comptes de service"

  2. Cliquez sur Sélectionner un projet.

  3. Sélectionnez votre projet et cliquez sur Ouvrir.

  4. Cliquez sur Créer un compte de service.

  5. Saisissez le nom du compte de service [SERVICE_ACCOUNT_NAME] (par exemple, storageservice), puis cliquez sur Créer.

  6. Sélectionnez le rôle "Administrateur des objets Storage", puis cliquez sur Continuer.

  7. Cliquez sur OK.

Créer un modèle d'instance

À l'aide de l'image Docker rqd-blender, créez un modèle d'instance pour déterminer le dimensionnement et les paramètres de la VM :

  1. Dans Cloud Console, accédez à la page Modèles d'instances.

    Accéder à la page "Modèles d'instances".

  2. Cliquez sur Créer un modèle d'instance.

  3. Donnez un nom à votre modèle d'instance (par exemple, rqd-blender).

  4. Dans le champ Type de machine, sélectionnez n1-highmem-2.

  5. Configurez les paramètres du Conteneur de la manière suivante :

  6. Dans la section Conteneur, cochez la case Déployer une image de conteneur dans cette instance de VM.

  7. Mettez à jour [PROJECT_NAME] et spécifiez l'image de conteneur suivante :

    gcr.io/[PROJECT_NAME]/opencue/rqd-blender:demo
    
  8. Autorisez l'accès aux périphériques système pour enregistrer vos instances RQD-Blender auprès de Cuebot au moment du démarrage :

    1. Cliquez sur Options avancées des conteneurs.
    2. Sélectionnez Exécuter avec accès privilégié.
    3. Cliquez sur Ajouter une variable sous Variable d'environnement, puis définissez NOM sur CUEBOT_HOSTNAME et VALEUR sur [CUEBOT_INTERNAL_IP_ADDRESS], qui fait référence à l'adresse IP interne de la VM Cuebot configurée précédemment.
  9. Configurez le compte de service de la manière suivante :

    1. Dans la section Compte de service, sélectionnez le compte [SERVICE_ACCOUNT_NAME] que vous avez créé précédemment.
    2. Conservez les autres paramètres par défaut.
    3. Cliquez sur Créer.

Créer un groupe d'instances géré

A l'aide du modèle d'instance, créez un groupe d'instances géré pour déterminer l'emplacement, le nombre d'instances et les paramètres d'autoscaling de la VM.

  1. Dans Cloud Console, accédez à la page Groupes d'instances.

    Accéder à la page "Groupes d'instances"

  2. Cliquez sur Créer un groupe d'instances.

  3. Saisissez un nom pour le groupe d'instances géré (par exemple, rqd-blender-mig).

  4. Sélectionnez Zone unique, puis la région us-central1 et la zone us-central1-a.

  5. Dans la section Type de groupe, sélectionnez Groupe d'instances géré.

  6. Sous Modèle d'instance, sélectionnez votre modèle d'instance (par exemple rqd-blender).

  7. Réglez Autoscaling sur Désactivé.

  8. Dans le champ Nombre d'instances, spécifiez 3.

  9. Cliquez sur Créer.

Configurer votre poste de travail local

Cuebot est désormais exécuté sur Google Cloud et prêt à gérer les hôtes de rendu et la file d'attente des tâches. Pour activer l'interface visuelle pour l'envoi et la gestion des tâches, configurez votre poste de travail local de manière à exécuter CueSubmit et CueGUI, puis connectez-vous depuis votre hôte local à Google Cloud.

Créer un répertoire et définir des autorisations pour le point d'installation du bucket

  • Créez un point d'installation pour le bucket Cloud Storage et définissez les autorisations nécessaires pour la lecture et l'écriture.

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

    Une fois installés sur votre poste de travail local et sur l'hôte de rendu, ces chemins d'accès correspondent à /shots/robotdanceparty/sh_05/sh_05_lores.blend pour votre fichier de scène d'animation d'entrée.

Installer le bucket du tutoriel

  • Demandez à gcsfuse d'installer le bucket du tutoriel sur votre ordinateur local en tant que système de fichiers sur le chemin d'accès /shots. L'option --implicit-dirs permet de guider le mappage d'objets sur des répertoires.

    gcsfuse --implicit-dirs $YOUR_BUCKET /shots
    

    Configurer le transfert SSH

Afin de renforcer la sécurité de la communication entre votre poste de travail local et Google Cloud, ce tutoriel utilise le transfert SSH. Les commandes suivantes ouvrent un port permettant de transférer les appels entre les interfaces OpenCue et Cuebot.

  1. Ouvrez une nouvelle interface système et réservez-la pour le processus SSH.
  2. Mettez à jour [YOUR_PROJECT_ID], puis exécutez les commandes suivantes :

    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
    

Initialiser un environnement virtuel

  1. Ouvrez une nouvelle fenêtre de l'interface système et réservez-la pour une utilisation ultérieure avec CueGUI et CueSubmit.
  2. Pour isoler votre environnement avant l'installation, exécutez virtualenv :

    cd ~/OpenCue
    virtualenv --python python2 venv
    

    Apprenez-en plus sur virtualenv.

  3. Rafraîchissez l'environnement virtuel et installez les dépendances à l'aide de pip.

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

    Vous pouvez exécuter cat requirements.txt pour afficher la liste des dépendances installées.

  4. Avant de démarrer CueGUI ou CueSubmit, définissez les variables requises pour le déploiement.

    export OPENCUE_ROOT=~/OpenCue
    export CUEBOT_HOSTS=localhost
    export PYTHONPATH=$OPENCUE_ROOT/pyoutline/:$OPENCUE_ROOT/pycue/:$OPENCUE_ROOT/cuesubmit/:$OPENCUE_ROOT/cuegui/
    
    Variable d'environnement Explication
    CUEBOT_HOSTS=localhost Référence à la façon dont PyCue se connecte à l'instance de Cuebot. Elle est définie en tant que localhost lors de l'utilisation du transfert SSH. Si vous utilisez un VPN ou une interconnexion dédiée, renseignez l'adresse IP de Cuebot.
    PYTHONPATH=$OPENCUE_ROOT Définit le chemin d'accès Python vers les bibliothèques OpenCue.

Compiler les fichiers proto de gRPC

OpenCue utilise gRPC comme protocole de communication pour envoyer des messages entre le serveur et les clients. Les services gRPC sont définis à l'aide de tampons de protocole dans un fichier .proto indépendant du langage. Pour autoriser les bibliothèques Python d'OpenCue à communiquer à l'aide de gRPC, procédez comme suit :

  • Compilez les fichiers de définition .proto dans les fichiers lisibles Python à l'aide des commandes suivantes :

    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
    

Exécuter les interfaces

Au cours des étapes suivantes, vous allez explorer OpenCue en envoyant une tâche à l'aide de CueSubmit, puis explorer les paramètres des tâches et des hôtes de rendu avec CueGUI. Ces deux outils utilisent le même environnement. Par conséquent, mettez en arrière-plan chacun de ces processus lors de leur exécution dans l'interface système de l'environnement virtuel.

Exécuter CueSubmit

  • Dans l'interface système de l'environnement de la VM, exécutez CueSubmit pour pouvoir envoyer une tâche :

    cd ~/OpenCue
    python cuesubmit/cuesubmit &
    

Envoyer une tâche

À l'aide de l'interface CueSubmit, renseignez les variables suivantes :

  1. Saisissez un Job Name (Nom de tâche). Par exemple : yourjobname.
  2. Saisissez un Shot (Plan). Par exemple : sh_05.
  3. Saisissez un Layer Name (Nom de calque). Par exemple : render.
  4. Dans le champ Command to Run (Commande à exécuter), saisissez ce qui suit :

    /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. Dans le champ Frame Spec (Spécifications de l'image), saisissez 600-700.

  6. Définissez le champ Job Type (Type de tâche) sur Shell.

  7. Définissez le champ Services sur shell.

  8. Conservez les autres valeurs par défaut et cliquez sur Submit (Envoyer).

    Une fenêtre s'affiche avec le message suivant : "Submitted Job to OpenCue." (Tâche soumise à OpenCue). L'identifiant et le nom de la tâche sont précisés pour vous aider à suivre la tâche au fur et à mesure de son rendu.

    Options de ligne de commande pour le rendu :

    Option de ligne de commande Description
    /usr/local/blender/blender Chemin d'accès vers l'exécutable Blender.
    -b Moteur de rendu à exécuter sans interface.
    -noaudio Moteur de rendu permettant de ne charger aucune bibliothèque audio.
    /shots/robotdanceparty/sh_05/sh_05_lores.blend Chemin d'accès vers le fichier de scène à rendre.
    -o /shots/renderimages/sh_05.lores.##### Définit le chemin de sortie, le nom et le remplissage de l'image. ##### correspond à l'image 650 au format sh_05.00650.jpg sur le disque.
    -F JPEG Définit le type de fichier de sortie au format JPEG.
    -f #IFRAME# Définit le numéro de l'image au moment du rendu et est spécifique à OpenCue. <Frame Spec> interagit avec cette variable. Saisissez-la telle quelle.

    Pour en savoir plus sur le rendu de ligne de commande Blender, consultez la documentation de Blender.

    Fenêtre Tâche soumise

    Variable Explication
    Job Name (Nom de la tâche) Une variable arbitraire que vous choisissez au début. La plupart des installations suivent les conventions de nommage pour autoriser le suivi des tâches de manière cohérente.
    User Name (Nom d'utilisateur) Rempli par OpenCue. Enregistré en tant qu'utilisateur ayant démarré CueSubmit.
    Show (Émission) OpenCue crée une émission par défaut nommé testing au début. La plupart des installations appellent des projets de film individuels ou des émissions commerciales dans ce contexte. Il est préférable d'ajouter et de modifier des émissions à l'aide des outils de ligne de commande CueAdmin.
    Shot (Plan) Une des séries d'images qui s'affichent pendant une période ininterrompue. À l'échelle d'un film, un plan correspond à ce qu'il se passe entre les directives "Action" et "Coupez". Généralement utilisé pour les plans individuels d'une séquence ou les rotations d'éléments lors de la pré-production.
    Layer (Calque) Une commande individuelle dans une soumission et une plage d'images. Dans cet exemple, vous exécutez un seul calque, rendu, dans votre tâche.
    Command to Run (Commande à exécuter) La commande que le calque va exécuter. Ici, vous exécutez un rendu de ligne de commande Blender.
    Frame Spec (Spécifications de l'image) Les images à traiter. Vous effectuez le rendu de l'image 600-700 de l'animation. Pointez vers la zone Frame Spec (Spécifications de l'image) pour consulter plus d'options, telles que l'affichage image par image et les entrées d'image arbitraires.
    Job Type (Type de tâche) Permet de définir le package logiciel utilisé pour ce calque dans une tâche. La commande que vous avez définie est interprétée comme un script d'interface système. Ainsi, saisissez Shell (Interface système).
    Services Liste des exigences, telles que la mémoire RAM minimale ou une ressource définie par l'utilisateur. Votre tâche ne nécessite pas d'exigences spécifiques en dehors de l'interface système. Ainsi, sélectionnez Shell (Interface système).
    Submission Details (Détails de l'envoi) Les résultats cumulés de vos paramètres.

Présentation de CueGUI

CueGUI est l'interface centrale d'un ensemble de modules d'interface utilisateur, chacun étant axé sur différents aspects de la ferme de rendu. Vous trouverez ci-dessous une liste de termes courants, d'explications et de modules connexes permettant de surveiller votre tâche et les hôtes de rendu. Pour une présentation plus détaillée de CueSubmit et de CueGui, regardez ce tutoriel vidéo.

Terme Explication Module CueGUI associé
job (tâche) Une soumission individuelle à OpenCue. Monitor Jobs (Surveiller les tâches)
Attributes (Attributs)
layer (calque) Une commande individuelle dans une soumission et une plage d'images. Dans cet exemple, vous exécutez un seul calque, rendu, dans votre tâche. Monitor Job Details (Surveiller les informations de la tâche)
Attributes (Attributs)
render host (hôte de rendu) Une ressource de rendu individuelle permettant de traiter une tâche. Monitor Job Details (Surveiller les informations de la tâche)
Monitor Hosts (Surveiller les hôtes)
LogView
Attributes (Attributs)
logs (journaux) Les hôtes de rendu écrivent des fichiers journaux sur le disque qui peuvent être analysés pour obtenir des informations, telles que des métriques de dépannage ou de performance. Monitor Job Details (Surveiller les informations de la tâche)
LogView
attributes (attributs) Une liste de détails sur une soumission ou une ressource OpenCue. La fenêtre Attribute (Attribut) peut charger des informations sur une tâche, un calque ou un hôte de rendu. Monitor Jobs (Surveiller les tâches)
Monitor Job Details (Surveiller les informations de la tâche)
Monitor Hosts (Surveiller les hôtes)
Attributes (Attributs)
tag Méthode de catégorisation pouvant être ajoutée à un hôte ou à un calque pour l'associer à certaines tâches. Ajoutez des tags d'hôtes pour les ressources disponibles sur chaque hôte de rendu et des tags de calque pour les ressources nécessaires au traitement de ce calque. Monitor Job Details (Surveiller les informations de la tâche)
Monitor Hosts (Surveiller les hôtes)
Attributes (Attributs)
layer tag (tag de calque) Un tag qui définit les exigences nécessaires au traitement d'un calque. Par exemple, un calque peut nécessiter un GPU. Vous devez donc ajouter un tag GPU au calque. Monitor Job Details (Surveiller les informations de la tâche)
Monitor Hosts (Surveiller les hôtes)
Attributes (Attributs)
host tag (tag d'hôte) Un tag qui définit une ressource disponible pour un hôte. Par exemple, vous pouvez ajouter une ressource GPU à un hôte sur lequel un GPU est installé.
Si ces tags et les ressources requises sont remplis, un hôte sélectionne un calque à rendre.
Monitor Job Details (Surveiller les informations de la tâche)
Monitor Hosts (Surveiller les hôtes)
Attributes (Attributs)

Ce tutoriel n'a pas pour objectif de couvrir l'intégralité de l'interface et des concepts d'OpenCue. Consultez la documentation pour obtenir des informations plus détaillées.

Exécuter CueGUI

  • Dans la même interface système de l'environnement virtuel, ouvrez CueGUI :

    cd ~/OpenCue
    python cuegui/cuegui &
    

Ouvrir la fenêtre "Monitor Jobs" (Surveiller les tâches)

  • Lorsque la fenêtre CueCommander s'ouvre, sélectionnez Views/Plug-ins (Vues/Plug-ins) > Cuetopia > Monitor Jobs (Surveiller les tâches).

À propos de la fenêtre "Monitor Jobs" (Surveiller les tâches)

La fenêtre Monitor Jobs (Surveiller les tâches) fonctionne au niveau des tâches. Elle agit donc comme une vue globale.

Fenêtre Surveiller les tâches dans OpenCue

Sur la ligne contenant [Your Job], recherchez les informations pertinentes suivantes pour mener à bien ce tutoriel :

  • Task (Tâche) : le nom de votre tâche est indiqué ici.
  • State (État) : cette tâche affiche l'état In Progress (En cours). Elle a été sélectionnée et effectue un rendu. Lorsque la tâche est terminée, la valeur State (État) est définie sur Finished (Terminée). Si la tâche rencontre un problème, l'état est défini sur Failing (En échec). Il est nécessaire de procéder au dépannage. Consultez la documentation pour en savoir plus sur le dépannage des rendus dans OpenCue.
  • Done/Total (Terminé/Total) : offre un aperçu de la progression de la tâche. Dans l'image ci-dessus, 100 images sur 101 sont terminées.
  • Running (En cours d'exécution) : vous informe du nombre d'images en cours de traitement sur les hôtes de rendu. Dans cette image, une seule image est en cours de traitement.
  • Progress (Progression) : offre un aperçu visuel de la progression de votre tâche.

Explorer la fenêtre "Monitor Jobs" (Surveiller les tâches)

  1. Surveillez la progression de votre tâche à l'aide de la fenêtre Monitor Jobs (Surveiller les tâches). Votre tâche devrait afficher l'état In Progress (En cours). Si l'état devient Failing (En échec), reportez-vous à la section Dépannage.
  2. Passez la souris sur le mot Progress (Progression). Une fenêtre de description s'affiche avec des informations utiles sur l'outil.
  3. Explorez l'interface en passant la souris sur les en-têtes et les icônes des autres lignes.
  4. Sélectionnez [Your Job].

Ouvrir la fenêtre "Monitor Job Details" (Surveiller les informations de la tâche)

  1. Pour ouvrir la fenêtre Monitor Jobs Details (Surveiller les informations de la tâche), sélectionnez Views/Plug-ins (Vues/Plug-ins) > Cuetopia > Monitor Job Details (Surveiller les informations de la tâche).
  2. Dans la fenêtre Monitor Jobs (Surveiller les tâches), double-cliquez sur [Your Job] pour charger ses données dans la fenêtre Monitor Jobs Details (Surveiller les informations de la tâche).

À propos de la fenêtre "Monitor Job Details" (Surveiller les informations de la tâche)

La fenêtre Monitor Job Details (Surveiller les informations de la tâche) fonctionne au niveau du calque et contient des informations détaillées sur votre tâche.

Fenêtre Surveiller les informations de la tâche dans OpenCue

Le module Monitor Job Details (Surveiller les informations de la tâche) comprend deux fenêtres :

  • Le volet Layer (Calque). Dans la fenêtre avec [Your Job] dans la barre de titre, le nom du calque s'affiche.
  • Le volet Layer Info (Informations sur le calque). Dans cette fenêtre, vous avez accès aux informations relatives à chaque image du calque sélectionné.

Présentation du volet Layer (Calque) :

  • Layer (Calque) : la tâche comprend un calque, le rendu. Si votre tâche comporte plusieurs calques, ils seront répertoriés ici. Effectuez un double-clic pour les sélectionner individuellement.
  • Avg (Moyenne) : le délai de rendu moyen par image de ce calque.
  • Tags : les tags au niveau des calques sont répertoriés ici. L'ajout de tags n'entre pas dans le cadre de ce tutoriel. Il s'agit d'un emplacement permettant d'accéder aux tags au niveau des calques.
  • Depend (Dépendances) : les dépendances de calque sont répertoriées ici. La gestion des dépendances n'entre pas dans le cadre de ce tutoriel. Il s'agit d'un emplacement permettant d'accéder aux dépendances au niveau des calques.

Présentation du volet Layer Info (Informations sur le calque) :

  • Bouton Refresh (Actualiser) : cliquez sur ce bouton pour actualiser l'interface avec les dernières informations de la base de données.
  • Order (Ordre) : l'ordre dans lequel les images sont rendues. Il est répertorié ici, car les images peuvent s'afficher dans un ordre arbitraire. Par exemple, vous pouvez effectuer le rendu toutes les 10 images, puis le reste des images, ou dans l'ordre inverse. Cet ordre est indiqué dans CueSubmit à l'aide de l'option "Frame Spec" (Spécifications de l'image) lorsque vous envoyez votre tâche.
  • Frame (Image) : le numéro d'image de la scène à rendre.
  • Status (État) : l'état de l'image. Dans l'image, ces images affichent l'état Succeeded (Effectué).
  • Host (Hôte) : l'adresse IP de l'hôte de rendu à laquelle l'image est associée.

Explorer la fenêtre "Monitor Job Details" (Surveiller les informations de la tâche)

  1. Cliquez sur Refresh (Actualiser) et examinez la progression de votre tâche dans la fenêtre Monitor Job Details (Surveiller les informations de la tâche).
  2. Passez la souris sur le mot Status (État). Une fenêtre de description s'affiche avec des informations utiles sur l'outil.
  3. Explorez l'interface en passant la souris sur les en-têtes et les icônes des autres lignes.

Ouvrir la fenêtre "LogView"

  • Pour ouvrir la fenêtre LogView, sélectionnez Views/Plug-ins (Vues/Plug-ins) > Other (Autres) > LogView.

À propos de la fenêtre "LogView"

La fenêtre LogView offre un aperçu rapide des journaux pour des images individuelles. Vous pouvez vous servir de cette vue pour collecter des informations à des fins de résolution de problèmes, redimensionner les VM lors de futurs rendus ou optimiser des rendus.

Fenêtre Afficher le journal dans OpenCue

Un fichier journal commence par un en-tête contenant des données spécifiques à OpenCue, puis affiche la sortie provenant du logiciel qui traite l'image. Dans cette instance, vous obtenez la configuration OpenCue, suivie de la sortie du journal Blender.

Explorer la fenêtre "LogView"

  1. Dans la fenêtre Monitor Job Details (Surveiller les informations de la tâche), sélectionnez une image affichant l'état SUCCEEDED (EFFECTUÉ) dans le volet Layer Info (Informations sur le calque) pour examiner les journaux.
  2. Notez la commande en cours d'exécution.
  3. Notez l'élément logDestination.

Vous pouvez en savoir plus sur la fenêtre LogView dans la documentation OpenCue.

Ouvrir la fenêtre "Monitor Hosts" (Surveiller les hôtes)

  • Pour ouvrir la fenêtre Monitor Hosts (Surveiller les hôtes), sélectionnez Views/Plug-ins (Vues/Plug-ins) > CueCommander > Monitor Hosts (Surveiller les hôtes).

À propos de la fenêtre "Monitor Hosts" (Surveiller les hôtes)

La fenêtre Monitor Hosts (Surveiller les hôtes) fournit des informations sur les hôtes de rendu individuels et constitue une interface permettant d'ajouter ou de supprimer des ressources à l'aide de tags.

Fenêtre Surveiller les hôtes dans OpenCue

Les informations suivantes sont utiles pour mener à bien ce tutoriel :

  • Auto-refresh box (Zone d'actualisation automatique) : cochez cette case pour actualiser la fenêtre Monitor Hosts (Surveiller les hôtes).
  • Refresh box (Zone d'actualisation) : cliquez sur ce bouton pour actualiser la fenêtre Monitor Hosts (Surveiller les hôtes).
  • IP address (Adresse IP) : l'adresse IP facilite le suivi des VM entre OpenCue et Google Cloud.
  • Load % (Charge moyenne) : charge moyenne sur l'hôte, ce qui constitue un bon indicateur de l'utilisation de la machine.
  • Mem (Mémoire) : allocation de mémoire de l'hôte.
  • Tags : ressources enregistrées sur l'hôte.

Explorer la fenêtre "Monitor Hosts" (Surveiller les hôtes)

  1. Cliquez sur Refresh (Actualiser) ou cochez la case Auto-refresh (Actualisation automatique).
  2. Sélectionnez un hôte de rendu en cliquant sur son adresse IP.
  3. Effectuez un clic droit sur l'hôte de rendu pour afficher d'autres options, telles que Delete Host (Supprimer l'hôte) ou Add or Remove Tags (Ajouter ou supprimer des tags).

    Consultez la documentation pour en savoir plus sur la gestion des ressources avec des tags.

  4. Double-cliquez sur un hôte pour vérifier ses attributs.

  5. Notez l'allocation, qui est définie sur local.general.

  6. Notez les tags (general) et l'adresse IP de l'hôte.

Ouvrir la fenêtre "Attributes" (Attributs)

  • Sélectionnez Views/Plug-ins (Vues/Plug-ins) > Other (Autres) > Attributes (Attributs).

À propos de la fenêtre "Attributes" (Attributs)

La fenêtre Attributes (Attributs) fournit une liste d'informations sur un hôte, un calque ou une tâche de rendu. Vous trouverez ci-dessous un exemple pour chaque élément.

Fenêtre Attributs d'OpenCue

Chaque fenêtre contient des informations pertinentes pour l'hôte, le calque ou la tâche. Le tag facility local (local de l'installation) dans le champ Job Attributes (Attributs de la tâche) et le tag general (général) dans le champ Layer Attributes (Attributs du calque) sont des indicateurs clés des exigences de cette soumission. Les images de cette tâche ne sélectionnent que les hôtes de rendu auxquels ces deux tags ont été attribués. Vous pouvez voir que ces tags sont attribués dans Host Attributes (Attributs de l'hôte) en consultant les lignes alloc et tags.

Explorer la fenêtre "Attributes" (Attributs)

  1. Dans la fenêtre Monitor Hosts (Surveiller les hôtes), cliquez sur une adresse IP d'hôte de rendu pour charger ses attributs.
  2. Dans la fenêtre Attributes (Attributs), vérifiez les paramètres alloc et tags.
  3. Dans la fenêtre Monitor Job Details (Surveiller les informations de la tâche), cliquez sur une image affichant l'état Succeeded (EFFECTUÉ) pour charger ses attributs.
  4. Dans la fenêtre Attributes (Attributs), explorez les paramètres minMemory (mémoire minimale) et tags.
  5. Dans la fenêtre Monitor Jobs (Surveiller les tâches), cliquez sur une tâche.
  6. Dans la fenêtre Attributes (Attributs), explorez les paramètres facility (installation) et minCores (nombre minimal de cœurs).

Pour une explication plus détaillée, consultez la documentation de référence CueGUI.

Vérifier les images rendues

Il existe plusieurs méthodes permettant de vérifier les images au fur et à mesure de leur rendu ou de les copier localement une fois l'opération terminée. L'installation d'outils de prévisualisation d'animations dépasse le cadre de ce tutoriel. Toutefois, vous pouvez utiliser Cloud Console pour prévisualiser des images individuelles ou les télécharger localement afin de les afficher dans l'application de visualisation d'images de votre choix.

  1. Dans Cloud Console, affichez une liste d'objets dans un bucket ou prévisualisez des images dans un navigateur :

    Accéder à la page Cloud Storage

  2. Cliquez sur [YOUR_BUCKET_NAME], puis sur renderimages pour afficher une liste d'images.

  3. Cliquez sur une image (par exemple, sh_05_lores.00650.jpg) pour afficher un aperçu dans la fenêtre de navigateur.

  4. Répertoriez les images dans le répertoire de sortie à l'aide de votre interface système locale :

      ls /shots/renderimages
    

    Vous pouvez également copier des fichiers localement ou les afficher dans l'outil de visualisation de votre choix.

  5. Utilisez gsutil pour répertorier les objets d'un bucket :

    gsutil ls gs://[YOUR_BUCKET_NAME]/renderimages
    
  6. Utilisez gsutil pour copier tous les objets du bucket dans un répertoire local, [LOCAL_DIRECTORY].

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

Surveiller la tâche effectuée

Si votre rendu est toujours en cours de traitement, vous pouvez choisir de le compléter et d'explorer davantage OpenCue. Vous pouvez également décider de l'arrêter en le supprimant dans la fenêtre Monitor Jobs (Surveiller les tâches).

Pour arrêter votre tâche dans OpenCue, procédez comme suit :

  1. Ouvrez la fenêtre Monitor Jobs (Surveiller les tâches).
  2. Sélectionnez [Your Job], puis cliquez sur le bouton Kill Job (Arrêter la tâche).
  3. Une fenêtre pop-up affiche la question suivante : "Are you sure you want to kill these jobs?" (Voulez-vous vraiment arrêter cette tâche ?).
  4. Cliquez sur OK pour arrêter la tâche.

(Facultatif) Explorer les options pour votre ferme de rendu

Afin de respecter la limite de huit processeurs virtuels au total de ce tutoriel, vous avez déployé des hôtes de rendu de taille modeste sur votre tâche de rendu. Supposons que vous ayez pour objectif de terminer la tâche rapidement ou de créer une animation adaptée au grand écran. Le cas échéant, vous pouvez déployer un plus grand nombre de ressources avec plus de processeurs en modifiant votre modèle d'instance de manière qu'il utilise un processeur virtuel n1-highcpu-4 (ou supérieur) et en créant un groupe d'instances géré pour contrôler le nombre total d'hôtes de rendu disponibles pour la tâche.

Vous avez effectué le rendu du fichier de scène suivant à basse résolution sur n1-standard-2 VM à raison d'environ une minute par image.

  • Fichier de scène :

    gs://[YOUR_BUCKET_NAME]/robotdanceparty/sh_05/sh_05_lores.blend
    
  • Image obtenue :

    Image en basse résolution de la danse du robot

    Le bucket du tutoriel contient un fichier de scène avec une résolution plus élevée qui, une fois rendu, crée des images semblables à celles-ci à l'aide d'une VM n1-highcpu-4 en huit minutes environ.

    Si vous souhaitez essayer d'autres options dans OpenCue, mettez à jour votre commande CueSubmit afin de référencer ce fichier doté d'une résolution plus élevée.

  • Fichier de scène :

    gs://[YOUR_BUCKET_NAME]/robotdanceparty/sh_05/sh_05.blend
    
  • Image obtenue :

    Même image de robot avec une résolution légèrement supérieure

(Facultatif) Demander une modification du quota

Si vous souhaitez augmenter le nombre d'hôtes de rendu ou utiliser des VM plus volumineuses, il vous faudra peut-être augmenter le quota associé à votre projet.

  1. Accédez à la page Quotas.

    Accéder à la page "Quotas"

  2. Sur la page Quotas, sélectionnez les quotas à modifier.

  3. En haut de la page, cliquez sur le bouton Modifier les quotas.

  4. Cochez la case du service que vous souhaitez modifier.

  5. Indiquez votre nom, votre adresse e-mail et votre numéro de téléphone, puis cliquez sur Suivant.

  6. Saisissez votre demande d'augmentation de quota et cliquez sur Suivant.

  7. Envoyez la demande.

Dépannage


Problème : problèmes liés au processus de création Docker.

Solution : essayez de créer le fichier Dockerfile avec l'option --no-cache, en obligeant Docker à utiliser des nouvelles données pour toutes les étapes. Consultez la documentation pour en savoir plus sur les options de création Docker.


Problème : erreur Connect Failed dans l'interface système lors du démarrage de CueSubmit ou de CueGUI. L'erreur ressemble généralement à ce qui suit :

Encountered a server error. StatusCode.UNAVAILABLE : Connect Failed

Solution : assurez-vous que le tunnel SSH fonctionne, puis redémarrez CueSubmit ou CueGUI.

  1. Exécutez la commande "Process status" (État du processus) dans une interface système locale pour vous assurer que le tunnel SSH est ouvert :

    ps aux | grep ssh.
    

    Une liste de processus s'affiche. L'un d'entre eux doit avoir une sortie semblable à la suivante (en affichant votre [USER_NAME], votre [PROJECT_NAME] et votre système d'exploitation) :

    [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. Assurez-vous que les éléments [USER_NAME], [PROJECT_NAME], --zone et le nom (cuebot) sont corrects pour votre déploiement.

  3. Arrêtez le processus SSH et reprenez les étapes décrites dans la section "Configurer le transfert SSH" de ce document pour ouvrir un nouveau tunnel SSH.


Problème : CueSubmit ou CueGUI sont ouverts, mais des erreurs s'affichent dans leur interface système de lancement.

Solution : connectez-vous à votre instance Cloud SQL et assurez-vous qu'elle a été remplie avec un schéma et des exemples de données. Si vous n'obtenez pas le résultat attendu, réimportez les fichiers dans la section Créer une base de données Cloud SQL (reportez-vous à l'étape "Importer le schéma de base de données et les données de démonstration").

  1. Dans Cloud Console, accédez à Cloud Shell et exécutez la commande suivante pour mettre à jour votre instance Cloud SQL. Remplacez [CLOUD_SQL_INSTANCE_ID] par le nom de votre instance.

    gcloud sql connect [CLOUD_SQL_INSTANCE_ID] --user=postgres
    
  2. Lorsque vous y êtes invité, mettez à jour [DATABASEPASSWORD] et appuyez sur Entrée :

    [DATABASEPASSWORD]
    
  3. Saisissez la commande suivante et appuyez sur Entrée :

    \c cuebot
    
  4. Saisissez à nouveau votre mot de passe lorsque vous y êtes invité, puis appuyez sur Entrée :

    [DATABASEPASSWORD]
    
  5. Saisissez la commande suivante :

    \d+
    

    Des résultats semblables à ceux-ci devraient s'afficher :

    >
    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 |
    

Problème : des erreurs s'affichent dans l'interface système CueSubmit ou CueGUI et aucun outil ne s'exécute.

Solution : assurez-vous que la connexion entre CueBot et votre base de données fonctionne en vérifiant les variables suivantes :

  1. Assurez-vous d'avoir correctement saisi [RESERVED_STATIC_IP_ADDRESS] lors de l'étape "Réseau" de la section Créer une instance Cloud SQL.
  2. Assurez-vous d'avoir saisi [CLOUD_SQL_IP_ADDRESS] et [DATABASEPASSWORD] lors de l'étape "Arguments de commande" de la section Configurer et provisionner la VM Cuebot.
  3. Assurez-vous d'avoir correctement renseigné l'adresse IP externe réservée lors de l'étape "Configurer les paramètres réseau" de la section Configurer et provisionner la VM Cuebot.

Problème : une tâche en cours de démarrage est répertoriée dans OpenCue, mais ne détecte pas les hôtes de rendu.

Solution : assurez-vous que les tags Job Facility (Installation de tâche) et Job Layer (Calque de tâche) correspondent aux tags Render Host (Hôte de rendu) attribués et que les exigences minimales en termes de ressources sont remplies. Pour en savoir plus, consultez les documents OpenCue Résoudre des problèmes liés au rendu et Résoudre des problèmes liés au déploiement.


Problème : les hôtes de rendu ne sont pas visibles dans CueGui.

Solution : plusieurs problèmes peuvent entraver l'affichage des hôtes. Il est probable que l'adresse IP interne de Cuebot ait été mal renseignée au moment du déploiement du modèle d'instance de l'hôte de rendu. Pour en savoir plus, consultez la documentation Résoudre des problèmes liés au déploiement.

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes