Création d’un script python pour télécharger la vidéo et sa miniature sur YouTube

📍 Ce tuto est le troisième d'une série en 4 étapes détaillées dans le sommaire.

1. Créer les identifiants sur Google Cloud

Retour sur Google Cloud. C’est l’étape la plus technique de cette automatisation.

Comme YouTube n'autorise pas les "comptes de service" pour publier des vidéos sur une chaîne YouTube. Nous devons donc créer une authentification OAuth 2.0 pour simuler une connexion humaine afin d'obtenir un jeton d'accès permanent.

1. Dans votre console Google Cloud, allez dans API et services > Identifiants.
2. Cliquez sur + Créer des identifiants > ID client OAuth,
3. Dans le formulaire qui apparaît :
   1. Choisissez Application de bureau
   2. Nommez-la différemment pour bien la distinguer de l'application Web précédemment créée. J'ai été particulièrement créative : j'ai nommé mon appli de bureau Lazy Lju Desktop 😉
   3. Cliquez sur Créer.
4. Dans la fenêtre modale qui apparaît, vous verrez les ID et codes secrets propres au client de votre nouvelle appli de bureau. Copiez bien ces informations, par exemple dans un fichier texte.
5. Téléchargez le fichier JSON disponible en bas de la fenêtre modale et renommez-le credentials.json.

Une fois créé, vous verrez votre nouvel identifiant dans la liste "ID client OAuth 2.0". Vous devriez avoir maintenant 2 applications : une appli web et une appli de bureau ; c'est cette dernière qui se chargera de simuler la connexion humaine réelle.

Pour les utilisateurs Google Workspace :

Vous pouvez choisir le mode "Interne" dans les paramètres OAuth. Cela signifie que l'application est considérée comme sûre pour tous les membres de votre organisation. Vous évitez ainsi le message d'avertissement "Application non validée" lors de la génération du token.json à l'étape suivante. Par ailleurs, il n'y a aucune limite de durée pour votre jeton d'accès. Le script Python (app.py) et le déploiement sur Cloud Run restent strictement les mêmes.

2. Générer le token d'authentification

1. Ouvrez l'éditeur Cloud Shell en cliquant sur l'icône >_ en haut à droite de votre console Google Cloud, acceptez toutes les demandes d'autorisation puis cliquez sur Ouvrir l'éditeur pour accéder à une interface similaire à Visual Studio Code.
2. Glissez-déposez votre fichier credentials.json directement dans l'explorateur de fichiers à gauche.
3. Créez un nouveau fichier nommé get_token.py et collez-y le code suivant qui force l'utilisation du port 8080.

from google_auth_oauthlib.flow import InstalledAppFlow

SCOPES = [
    'https://www.googleapis.com/auth/drive.readonly',
    'https://www.googleapis.com/auth/youtube.upload'
]

# On force l'URI de redirection pour correspondre aux attentes de Google
flow = InstalledAppFlow.from_client_secrets_file(
    'credentials.json', 
    scopes=SCOPES,
    redirect_uri='http://localhost:8080/'
)

auth_url, _ = flow.authorization_url(access_type='offline', prompt='consent')

print(f"\n1. Ouvrez ce lien dans votre navigateur :\n{auth_url}\n")
code = input("2. Après avoir validé, copiez le code fourni par Google et collez-le ici : ")

flow.fetch_token(code=code)

with open('token.json', 'w') as token:
    token.write(flow.credentials.to_json())

print("\nFichier token.json généré avec succès !")

Enregistrez le fichier.

Ensuite, rendez-vous dans le terminal du Cloud Shell :

1. Tapez pip install google-auth-oauthlib et installez toutes les librairies nécessaires.
2. Tapez python3 get_token.py afin de générer un token qui permettra à votre script d'agir en votre nom de manière permanente.
3. Cliquez sur le lien qui s'affiche dans la console et :
   1. Connectez-vous avec votre compte Google dans la fenêtre qui apparaît
   2. Sélectionnez votre chaîne YouTube
   3. Une alerte de sécurité s'affiche alors : "Google n'a pas validé cette application". C'est tout à fait attendu ! Cliquez sur Paramètres avancés puis sur Accéder à [Nom de votre projet] (non sécurisé) pour continuer.
   4. Validez tous les accès (c'est important de cocher toutes les cases !) et cliquez sur Continuer.
4. Une page affichant le message "Ce site est inaccesible" doit alors s'ouvrir. Ne la fermez surtout pas ! Là encore, c'est normal : le script tourne sur les serveurs de Google (Cloud Shell) et non sur votre ordinateur personnel. Par ailleurs, le script get_token.py attend un code qui se trouve directement dans la barre d'adresse de votre navigateur :
   1. Allez dans la barre d'adresse de l'onglet du navigateur qui affiche l'erreur "Ce site est inaccesible".
   2. Repérez la partie qui commence après code=. Copiez la longue suite de caractères et arrêtez-vous juste avant le &scope.
   3. Retournez dans votre terminal Cloud Shell où le script est en attente.
   4. Collez le code avec ctrl+v / pomme+v et appuyez sur Entrée.
5. Le message "Fichier token.json généré avec succès !" doit apparaître dans le terminal : le token.json est alors créé automatiquement. Vérifiez que ce fichier est bien apparu dans votre explorateur de fichiers : regardez dans l'explorateur de fichiers à gauche de votre éditeur Cloud Shell pour vérifier que le nouveau fichier token.json est bien apparu.

3. Créer le script app.py, le fichier requirements.txt et le Dockerfile

Toujours dans l'éditeur Cloud Shell, créez les trois fichiers suivants nécessaires au fonctionnement de votre programme :

3.1. Créer le script app.py (python)

C’est le cœur du programme qui reçoit l'ordre de Make.com, télécharge la vidéo et sa miniature depuis Drive et les envoie sur YouTube par morceaux (resumable upload) pour éviter les erreurs. Copiez-collez le code python suivant :

import os
from flask import Flask, request, jsonify
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
from googleapiclient.http import MediaIoBaseDownload, MediaFileUpload

app = Flask(__name__)
SCOPES = ['https://www.googleapis.com/auth/drive.readonly', 'https://www.googleapis.com/auth/youtube.upload']

API_KEY = "VOTRE_CLE_DE_SECURITE"

@app.route('/upload', methods=['POST'])
def upload_video():
    # Vérification de sécurité
    if request.headers.get('X-API-Key') != API_KEY:
        return jsonify({"error": "Accès refusé"}), 403
    data = request.json
    creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    drive_service = build('drive', 'v3', credentials=creds)
    youtube_service = build('youtube', 'v3', credentials=creds)
    
    # 1. Téléchargement de la vidéo depuis Google Drive
    temp_video = '/tmp/video.mp4'
    request_drive = drive_service.files().get_media(fileId=data['drive_id'])
    with open(temp_video, 'wb') as f:
        downloader = MediaIoBaseDownload(f, request_drive)
        done = False
        while not done:
            _, done = downloader.next_chunk()

    # 2. Envoi de la vidéo vers YouTube
    body = {
        'snippet': {
            'title': data.get('title', 'Vidéo sans titre'),
            'description': data.get('desc', 'Publié via automation')
        },
        'status': {'privacyStatus': data.get('privacy', 'private')}
    }
    media = MediaFileUpload(temp_video, chunksize=1024*1024*5, resumable=True)
    request_yt = youtube_service.videos().insert(part=','.join(body.keys()), body=body, media_body=media)
    
    yt_response = None
    while yt_response is None:
        _, yt_response = request_yt.next_chunk()
    
    video_id = yt_response['id']

    # 3. Gestion de la miniature (si un thumbnail_id est fourni)
    if data.get('thumbnail_id'):
        temp_thumb = '/tmp/thumbnail' # Pas d'extension nécessaire ici
        request_thumb = drive_service.files().get_media(fileId=data['thumbnail_id'])
        with open(temp_thumb, 'wb') as f:
            downloader_thumb = MediaIoBaseDownload(f, request_thumb)
            done_t = False
            while not done_t:
                _, done_t = downloader_thumb.next_chunk()
        
        # Application de la miniature sur YouTube
        youtube_service.thumbnails().set(
            videoId=video_id,
            media_body=MediaFileUpload(temp_thumb)
        ).execute()
        os.remove(temp_thumb)

    # Nettoyage final
    os.remove(temp_video)
    return jsonify({"success": True, "youtube_id": video_id}), 200

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 8080)))

Sauvegardez le fichier.

⚠️ Ajouter une clé de sécurité pour que seul Make puisse utiliser votre script en python

Votre URL Cloud Run est actuellement publique : sans protection, n'importe qui possédant cette adresse peut techniquement déclencher votre script. Nous allons donc ajouter une protection par le biais d'une clé secrète afin de garantir :

• La protection financière : bien que le quota gratuit de Google Cloud soit immense (2 millions de requêtes par mois), un acteur malveillant pourrait "spammer" votre URL pour vider votre forfait et engendrer des frais sur votre carte de crédit une fois la limite dépassée.
• Le contrôle des ressources : cela garantit que seul votre scénario Make.com consomme le temps de calcul (CPU) et la mémoire alloués à votre service.
• La sécurité du contenu : vous évitez que quelqu'un ne s'amuse à déclencher des uploads non désirés sur votre chaîne YouTube.

Pour ce faire :

1. Repérez la ligne #10 du script qui devrait contenir : API_KEY = "VOTRE_CLE_DE_SECURITE"
2. Remplacez le texte entre guillemets par la clé de sécurité personnelle de votre choix. Notez-là précieusement, nous en aurons besoin lors de la création du scenario sur Make (📍 partie 4 : Automatisation YouTube : le scenario Make.com complet).

3.2. Créer le fichier requirements.txt (texte)

Listez simplement les bibliothèques suivantes avec leurs versions respectives :

Flask==3.0.0
google-api-python-client==2.115.0
google-auth-oauthlib==1.2.0
google-auth-httplib2==0.2.0

3.3. Créer le Dockerfile

Collez le code suivant dans un nouveau fichier type Dockerfile pour expliquer à Google comment construire l'ordinateur virtuel pour votre script :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]

4. Déployer le script python sur Google Cloud Run

Une fois que vous avez vos 5 fichiers (credentials.json, token.json, app.py, requirements.txt, Dockerfile) dans le même dossier, vous allez pouvoir lancer le déploiement :

1. Dans le terminal, tapez cette commande précise : gcloud run deploy --source . puis appuyez sur Entrée.
2. Confirmez le Service name en appuyant à nouveau sur Entrée.
3. Google Cloud vous prompte à présent d'activer 3 APIs. Appuyez sur y puis sur Entrée pour accepter.
4. Vous devriez à présent avoir le message d'erreur suivant :

ERROR: (gcloud.run.deploy) FAILED_PRECONDITION: Billing account for project 'xxxxxxxxxxxxx' is not found. Billing must be enabled for activation of service(s) 'artifactregistry.googleapis.com,  cloudbuild.googleapis.com, run.googleapis.com, containerregistry.googleapis.com' to proceed.

Google Cloud Run exige d'activer la facturation pour utiliser ces APIs. Pas de panique, nous n'aurons qu'à ajouter un moyen de paiement.

Activer la facturation pour Google Cloud Run

ℹ️ Aucun frais n'est à prévoir, puisque les ressources consommées par l'automatisation restent largement en dessous des quotas payants. Google cherche simplement à se protéger les fraudes potentielles en imposant un moyen de facturation. Le scenario tourne depuis des semaines et pas un euro n'a été prélevé sur le compte bancaire de ma maman !

1. Accédez à Google Cloud Run en vous assurant que le bon projet est bien actif. Dans le menu hamburger en haut à gauche, cliquez sur Facturation.
2. Cliquez sur Associer un compte de facturation et suivez la procédure pour ajouter un moyen de paiement.

Finaliser le déploiement du script python

Retournez sur le terminal Google Cloud Shell et :

1. Tapez à nouveau la commande de déploiement : gcloud run deploy --source . et acceptez d'installer les APIs requises en tapant y puis Entrée.
2. Une fois lancée, la console vous posera quelques questions :
   1. Service name : appuyez sur Entrée pour garder le nom par défaut.
   2. Region : choisissez une région proche de vous (comme europe-west1 pour la Belgique ou europe-west9 pour Paris) en tapant son numéro puis Entrée.
   3. Allow unauthenticated invocations : répondez impérativement y (yes) pour que Make.com puisse contacter votre script.
   4. Patientez quelques minutes le temps que l'installation soit complète. Vous alors devriez voir le message suivant : Service [nomdevotreservice] revision [nomdevotreservice-00001-xs5] has been deployed and is serving 100 percent of traffic.
3. Pour finaliser le déploiement, une dernière configuration critique est nécessaire. Il est impératif d'augmenter le Request timeout et d'allouer assez de RAM pour que les vidéos lourdes ne fassent pas planter le système :
   1. Accédez à Google Cloud Run en vous assurant que le bon projet est bien actif.
   2. Sélectionnez Services dans le menu de navigation Cloud Run, puis cliquez sur Modifier et déployer la nouvelle révision.Cliquez sur l'onglet Conteneur.
   3. Dans le champ Délai avant expiration de la requête, saisissez 3600 secondes (60 minutes).
   4. Dans le champ Limite de mémoire, appliquez la valeur d’1 Gio.
   5. Cliquez sur Déployer.

🎉 Félicitations, votre script en python est dorénavant opérationnel !

ℹ️ Passons dès à présent à la dernière partie du tutoriel : Automatisation YouTube : le scenario Make.com complet.