Cloud Composer 1 | Cloud Composer 2 | Cloud Composer 3
Ce tutoriel explique comment déboguer un DAG Airflow ayant échoué dans Cloud Composer et diagnostiquer les problèmes liés aux ressources des nœuds de calcul, tels que le manque de mémoire ou d'espace de stockage pour les nœuds de calcul, à l'aide des journaux et de la surveillance de l'environnement.
Introduction
Ce tutoriel se concentre sur les problèmes liés aux ressources pour montrer comment déboguer un DAG.
L'absence de ressources de nœuds de calcul allouées entraîne l'échec du DAG. Si une tâche Airflow manque de mémoire ou de stockage, une exception Airflow peut s'afficher, par exemple:
WARNING airflow.exceptions.AirflowException: Task received SIGTERM signal
INFO - Marking task as FAILED.
ou
Task exited with return code Negsignal.SIGKILL
Dans ce cas, il est généralement recommandé d'augmenter les ressources des nœuds de calcul Airflow ou de réduire le nombre de tâches par nœud de calcul. Toutefois, comme les exceptions Airflow peuvent être génériques, il peut être difficile d'identifier la ressource spécifique à l'origine du problème.
Ce tutoriel explique comment diagnostiquer la cause d'un échec de DAG et identifier le type de ressource à l'origine des problèmes en déboguant deux exemples de DAG qui échouent en raison d'un manque de mémoire et d'espace de stockage pour les nœuds de calcul.
Objectifs
Exécutez des exemples de DAG qui échouent pour les raisons suivantes:
- Mémoire de nœud de calcul insuffisante
- Espace de stockage insuffisant pour les nœuds de calcul
Diagnostiquer les raisons de l'échec
Augmenter les ressources de nœuds de calcul allouées
Tester les DAG avec de nouvelles limites de ressources
Coûts
Ce tutoriel utilise les composants facturables suivants de Google Cloud :
- Cloud Composer (voir les coûts supplémentaires)
- Cloud Monitoring
Une fois que vous avez terminé ce tutoriel, évitez de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez Effectuer un nettoyage.
Avant de commencer
Cette section décrit les actions requises avant de commencer le tutoriel.
Créer et configurer un projet
Pour ce tutoriel, vous avez besoin d'un projet Google Cloud. Configurez le projet comme suit:
Dans la console Google Cloud, sélectionnez ou créez un projet:
Assurez-vous que la facturation est activée pour votre projet. Découvrez comment vérifier si la facturation est activée sur un projet.
Assurez-vous que l'utilisateur de votre projet Google Cloud dispose des rôles suivants pour créer les ressources nécessaires:
- Administrateur de l'environnement et des objets Storage (
roles/composer.environmentAndStorageObjectAdmin
) - Administrateur de Compute (
roles/compute.admin
) - Éditeur Monitoring (
roles/monitoring.editor
)
- Administrateur de l'environnement et des objets Storage (
Activer les API pour votre projet.
Activez l'API Cloud Composer
Créer votre environnement Cloud Composer
Créez un environnement Cloud Composer 2.
Dans le cadre de la création de l'environnement, vous attribuez le rôle Extension d'agent de service de l'API Cloud Composer v2 (roles/composer.ServiceAgentV2Ext
) au compte d'agent de service Composer. Cloud Composer utilise ce compte pour effectuer des opérations dans votre projet Google Cloud.
Vérifier les limites de ressources de nœuds de calcul
Vérifiez les limites de ressources de nœuds de calcul Airflow dans votre environnement:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Configuration de l'environnement.
Accédez à Ressources > Configuration des charges de travail > Nœud de calcul.
Vérifiez que les valeurs correspondent à 0,5 vCPU, 1,875 Go de mémoire et 1 Go de stockage. Voici les limites de ressources de nœuds de calcul Airflow que vous utiliserez dans les étapes suivantes de ce tutoriel.
Exemple: diagnostiquer les problèmes de mémoire saturée
Importez l'exemple de DAG suivant dans l'environnement que vous avez créé aux étapes précédentes. Dans ce tutoriel, ce DAG est nommé create_list_with_many_strings
.
Ce DAG contient une tâche qui exécute les étapes suivantes:
- Crée une liste
s
vide. - Exécute un cycle pour ajouter la chaîne
More
à la liste. - Affiche la quantité de mémoire consommée par la liste et attend une seconde à chaque itération d'une minute.
import time
import airflow
from airflow import DAG
from airflow.operators.python_operator import PythonOperator
import sys
from datetime import timedelta
default_args = {
'start_date': airflow.utils.dates.days_ago(0),
'retries': 0,
'retry_delay': timedelta(minutes=10)
}
dag = DAG(
'create_list_with_many_strings',
default_args=default_args,
schedule_interval=None)
def consume():
s = []
for i in range(120):
for j in range(1000000):
s.append("More")
print(f"i={i}; size={sys.getsizeof(s) / (1000**3)}GB")
time.sleep(1)
t1 = PythonOperator(
task_id='task0',
python_callable=consume,
dag=dag,
depends_on_past=False,
retries=0
)
Déclencher l'exemple de DAG
Déclenchez l'exemple de DAG create_list_with_many_strings
:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la colonne Serveur Web Airflow, cliquez sur le lien Airflow correspondant à votre environnement.
Dans l'interface Web Airflow, sur la page DAG, dans la colonne Liens de votre DAG, cliquez sur le bouton Déclencher le DAG.
Cliquez sur Déclencher.
Sur la page DAG, cliquez sur la tâche que vous avez déclenchée et examinez les journaux de sortie pour vous assurer que votre DAG a démarré.
Pendant l'exécution de la tâche, les journaux de sortie afficheront la taille de la mémoire (en Go) utilisée par le DAG.
Après plusieurs minutes, la tâche échoue, car elle dépasse la limite de mémoire des nœuds de calcul Airflow de 1,875 Go.
Diagnostiquer le DAG ayant échoué
Si vous exécutiez plusieurs tâches au moment de l'échec, envisagez de n'exécuter qu'une seule tâche et de diagnostiquer la pression des ressources pendant cette période afin d'identifier les tâches à l'origine de la pression sur les ressources et celles que vous devez augmenter.
Examiner les journaux de tâches Airflow
Notez que la tâche du DAG create_list_with_many_strings
présente l'état Failed
.
Examinez les journaux de la tâche. L'entrée de journal suivante s'affiche:
```none
{local_task_job.py:102} INFO - Task exited with return code
Negsignal.SIGKILL
```
`Netsignal.SIGKILL` might be an indication of your task using more memory
than the Airflow worker is allocated. The system sends
the `Negsignal.SIGKILL` signal to avoid further memory consumption.
Examiner les charges de travail
Examinez les charges de travail pour vérifier que la charge de votre tâche n'entraîne pas le dépassement de la limite de consommation de mémoire par le nœud sur lequel le pod s'exécute:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Configuration de l'environnement.
Dans Ressources > Cluster GKE > Charges de travail, cliquez sur Afficher les charges de travail du cluster.
Vérifiez si certains pods de charge de travail ont un état semblable à celui-ci:
Error with exit code 137 and 1 more issue. ContainerStatusUnknown with exit code 137 and 1 more issue
Exit code 137
signifie qu'un conteneur ou un pod tente d'utiliser plus de mémoire que ce qui est autorisé. Le processus est arrêté pour empêcher l'utilisation de la mémoire.
Examiner la surveillance de l'état de l'environnement et de la consommation des ressources
Examinez la surveillance de l'état de l'environnement et de la consommation des ressources:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Surveillance, puis sélectionnez Présentation.
Dans le panneau Présentation de l'environnement, localisez le graphique État de l'environnement (DAG de surveillance Airflow). Il contient une zone rouge, qui correspond à l'heure à laquelle les journaux ont commencé à imprimer des erreurs.
Sélectionnez Nœuds de calcul, puis recherchez le graphique Utilisation totale de la mémoire des nœuds de calcul. Notez que la ligne Utilisation de la mémoire présente un pic au moment de l'exécution de la tâche.
![La ligne d'utilisation de la mémoire présente un pic au moment de l'exécution de la tâche.](https://cloud.google.com/static/composer/docs/images/composer-workers-memory-usage.png?authuser=7&hl=fr)
Même si la ligne d'utilisation de la mémoire sur le graphique n'atteint pas la limite, lorsque vous diagnostiquez les causes de l'échec, vous ne devez prendre en compte que la mémoire pouvant être allouée, tandis que la ligne Limite de mémoire du graphique représente la mémoire totale disponible (y compris la capacité réservée par GKE).
Dans cet exemple, la limite de mémoire du nœud de calcul est définie sur 1,875 Go. GKE réserve 25% des 4 premiers Gio de mémoire. GKE réserve également un seuil d'éviction supplémentaire, soit 100 Mio de mémoire sur chaque nœud pour l'éviction du kubelet.
La mémoire pouvant être allouée est calculée comme suit:
ALLOCATABLE = CAPACITY - RESERVED - EVICTION-THRESHOLD
Si la limite de mémoire est de 1,875 Go, la mémoire réelle pouvant être allouée est la suivante:
1.75 GiB (1.875GB) - 0.44 (25% GiB reserved) - 0.1 = 1.21 GiB (~1.3 GB).
Lorsque vous ajoutez cette limite réelle au graphique d'utilisation de la mémoire, vous constatez que le pic d'utilisation de la mémoire de la tâche atteint la limite réelle de mémoire. Vous pouvez en conclure que la tâche a échoué en raison d'une mémoire de nœud de calcul insuffisante.
Augmenter la limite de mémoire des nœuds de calcul
Allouez de la mémoire de nœud de calcul supplémentaire pour que l'exemple de DAG réussisse:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Configuration de l'environnement.
Accédez à Resources > Workloads (Ressources > Configuration des charges de travail), puis cliquez sur Edit (Modifier).
Dans le champ Memory (Mémoire) de la section Worker (Nœud de calcul), spécifiez la nouvelle limite de mémoire pour les nœuds de calcul Airflow. Dans ce tutoriel, utilisez 3 Go.
Enregistrez les modifications et attendez quelques minutes pour que vos nœuds de calcul Airflow redémarrent.
Tester votre DAG avec la nouvelle limite de mémoire
Déclenchez à nouveau le DAG create_list_with_many_strings
et attendez la fin de son exécution.
Dans les journaux de sortie de l'exécution de votre DAG, vous verrez
Marking task as SUCCESS
et l'état de la tâche indiquera Success (Opération réussie).Consultez la section Présentation de l'environnement dans l'onglet Surveillance et vérifiez qu'il n'y a pas de zone rouge.
Cliquez sur la section Nœuds de calcul et recherchez le graphique Utilisation totale de la mémoire des nœuds de calcul. Vous constaterez que la ligne Memory limit (Limite de mémoire) reflète la modification de la limite de mémoire et que la ligne Memory usage (Utilisation de la mémoire) est nettement inférieure à la limite réelle de mémoire pouvant être allouée.
Exemple: Diagnostiquer les problèmes d'espace de stockage insuffisant
Au cours de cette étape, vous allez importer deux DAG qui créent des fichiers volumineux. Le premier DAG crée un fichier volumineux. Le deuxième DAG crée un fichier volumineux et imite une opération de longue durée.
La taille du fichier dans les deux DAG dépasse la limite de stockage par défaut des nœuds de calcul Airflow, qui est de 1 Go. Toutefois, le second DAG a une tâche d'attente supplémentaire pour prolonger artificiellement sa durée.
Vous examinerez les différences de comportement des deux DAG dans les prochaines étapes.
Importer un DAG qui crée un fichier volumineux
Importez l'exemple de DAG suivant dans l'environnement que vous avez créé aux étapes précédentes. Dans ce tutoriel, ce DAG est nommé create_large_txt_file_print_logs
.
Ce DAG contient une tâche qui exécute les étapes suivantes:
- Écrit un fichier
localfile.txt
de 1,5 Go dans l'espace de stockage des nœuds de calcul Airflow. - Affiche la taille du fichier créé à l'aide du module Python
os
. - Affiche la durée de l'exécution du DAG toutes les minutes.
import airflow
from airflow import DAG
from airflow.operators.python_operator import PythonOperator
import os
from datetime import timedelta
import time
default_args = {
'start_date': airflow.utils.dates.days_ago(0),
'retries': 0,
'retry_delay': timedelta(minutes=10)
}
dag = DAG(
'create_large_txt_file_print_logs',
default_args=default_args,
schedule_interval=None)
def consume():
size = 1000**2 # bytes in 1 MB
amount = 100
def create_file():
print(f"Start creating a huge file")
with open("localfile.txt", "ab") as f:
for j in range(15):
f.write(os.urandom(amount) * size)
print("localfile.txt size:", os.stat("localfile.txt").st_size / (1000**3), "GB")
create_file()
print("Success!")
t1 = PythonOperator(
task_id='create_huge_file',
python_callable=consume,
dag=dag,
depends_on_past=False,
retries=0)
Importer un DAG qui crée un fichier volumineux dans une opération de longue durée
Pour imiter un DAG de longue durée et étudier l'impact de la durée de la tâche sur l'état final, importez le deuxième exemple de DAG dans votre environnement. Dans ce tutoriel, ce DAG est nommé long_running_create_large_txt_file_print_logs
.
Ce DAG contient une tâche qui exécute les étapes suivantes:
- Écrit un fichier
localfile.txt
de 1,5 Go dans l'espace de stockage des nœuds de calcul Airflow. - Affiche la taille du fichier créé à l'aide du module Python
os
. - Attend 1 heure et 15 minutes pour imiter le temps nécessaire aux opérations avec le fichier, par exemple la lecture du fichier.
- Affiche la durée de l'exécution du DAG toutes les minutes.
import airflow
from airflow import DAG
from airflow.operators.python_operator import PythonOperator
import os
from datetime import timedelta
import time
default_args = {
'start_date': airflow.utils.dates.days_ago(0),
'retries': 0,
'retry_delay': timedelta(minutes=10)
}
dag = DAG(
'long_running_create_large_txt_file_print_logs',
default_args=default_args,
schedule_interval=None)
def consume():
size = 1000**2 # bytes in 1 MB
amount = 100
def create_file():
print(f"Start creating a huge file")
with open("localfile.txt", "ab") as f:
for j in range(15):
f.write(os.urandom(amount) * size)
print("localfile.txt size:", os.stat("localfile.txt").st_size / (1000**3), "GB")
create_file()
for k in range(75):
time.sleep(60)
print(f"{k+1} minute")
print("Success!")
t1 = PythonOperator(
task_id='create_huge_file',
python_callable=consume,
dag=dag,
depends_on_past=False,
retries=0)
Déclencher des exemples de DAG
Déclenchez le premier DAG, create_large_txt_file_print_logs
:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la colonne Serveur Web Airflow, cliquez sur le lien Airflow correspondant à votre environnement.
Dans l'interface Web Airflow, sur la page DAG, dans la colonne Liens de votre DAG, cliquez sur le bouton Déclencher le DAG.
Cliquez sur Déclencher.
Sur la page DAG, cliquez sur la tâche que vous avez déclenchée et examinez les journaux de sortie pour vous assurer que votre DAG a démarré.
Attendez la fin de la tâche que vous avez créée avec le DAG
create_large_txt_file_print_logs
. Cette opération peut prendre plusieurs minutes.Sur la page DAG, cliquez sur l'exécution du DAG. Votre tâche est à l'état
Success
, même si la limite de stockage a été dépassée.
Examinez les journaux Airflow pour la tâche:
Dans la console Google Cloud, accédez à la page Environnements.
Accéder à la page Environnements
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Journaux, puis à Tous les journaux > Journaux Airflow > Nœuds de calcul > Afficher dans l'explorateur de journaux.
Filtrez les journaux par type: affichez uniquement les messages d'erreur.
Dans les journaux, vous verrez des messages semblables à ceux-ci:
Worker: warm shutdown (Main Process)
ou
A worker pod was evicted at 2023-12-01T12:30:05Z with message: Pod ephemeral
local storage usage exceeds the total limit of containers 1023Mi.
Ces journaux indiquent que le pod a lancé le processus d'"arrêt tiède", car l'espace de stockage utilisé a dépassé la limite et a été évincé en une heure. Cependant, l'exécution du DAG n'a pas échoué, car elle s'est terminée pendant le délai de grâce pour l'arrêt de Kubernetes, qui est expliqué plus en détail dans ce tutoriel.
Pour illustrer le concept de délai de grâce pour l'arrêt, examinez le résultat du deuxième exemple de DAG, long_running_create_large_txt_file_print_logs
.
Déclenchez le deuxième DAG, long_running_create_large_txt_file_print_logs
:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la colonne Serveur Web Airflow, cliquez sur le lien Airflow correspondant à votre environnement.
Dans l'interface Web Airflow, sur la page DAG, dans la colonne Liens de votre DAG, cliquez sur le bouton Déclencher le DAG.
Cliquez sur Déclencher.
Sur la page DAG, cliquez sur la tâche que vous avez déclenchée et examinez les journaux de sortie pour vous assurer que votre DAG a démarré.
Attendez que l'exécution du DAG
long_running_create_large_txt_file_print_logs
échoue. Cela prendra environ une heure.
Examinez les résultats de l'exécution du DAG:
Sur la page DAG, cliquez sur l'exécution du DAG
long_running_create_large_txt_file_print_logs
. Vous verrez que la tâche est à l'étatFailed
et que la durée d'exécution était d'exactement 1 heure 5 minutes, ce qui est inférieur au délai d'attente de la tâche (1 heure 15 minutes).Examinez les journaux de la tâche. Une fois que le DAG a créé le fichier
localfile.txt
dans le conteneur du nœud de calcul Airflow, le journal indique que le DAG a commencé à attendre, et la durée de l'exécution est imprimée dans les journaux de la tâche toutes les minutes. Dans cet exemple, le DAG imprime le journallocalfile.txt size:
et la taille du fichierlocalfile.txt
est de 1,5 Go.
Une fois que le fichier écrit dans le conteneur du nœud de calcul Airflow dépasse la limite de stockage, l'exécution du DAG est censée échouer. Cependant, la tâche n'échoue pas immédiatement et continue de s'exécuter jusqu'à ce que sa durée atteigne 1 heure et 5 minutes. En effet, Kubernetes n'arrête pas la tâche immédiatement et continue de s'exécuter afin de laisser une heure de temps de récupération, appelé "délai de grâce pour l'arrêt". Lorsqu'un nœud est à court de ressources, Kubernetes n'arrête pas le pod immédiatement pour gérer l'arrêt en douceur, de sorte que l'impact sur l'utilisateur final soit minimal.
Le délai de grâce pour l'arrêt aide les utilisateurs à récupérer des fichiers après des échecs de tâches, mais il peut prêter à confusion lors du diagnostic des DAG. Lorsque la limite de stockage des nœuds de calcul Airflow est dépassée, l'état de la tâche de fin dépend de la durée d'exécution du DAG:
Si l'exécution du DAG dépasse la limite de stockage des nœuds de calcul, mais se termine en moins d'une heure, la tâche se termine avec l'état
Success
, car elle a été terminée dans le délai de grâce pour la résiliation. Cependant, Kubernetes arrête le pod et le fichier écrit est immédiatement supprimé du conteneur.Si le DAG dépasse la limite de stockage des nœuds de calcul et s'exécute pendant plus d'une heure, il continue de s'exécuter pendant une heure et peut dépasser la limite de stockage de milliers de pour cent avant que Kubernetes n'élimine le pod et qu'Airflow marque la tâche comme
Failed
.
Diagnostiquer le DAG ayant échoué
Si vous exécutiez plusieurs tâches au moment de l'échec, envisagez de n'exécuter qu'une seule tâche et de diagnostiquer la pression des ressources pendant cette période afin d'identifier les tâches à l'origine de la pression sur les ressources et celles que vous devez augmenter.
Examinez les journaux de tâches du deuxième DAG, long_running_create_large_txt_file_print_logs
:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Journaux, puis à Tous les journaux > Journaux Airflow > Nœuds de calcul > Afficher dans l'explorateur de journaux.
Filtrez les journaux par type: affichez uniquement les messages d'erreur.
Dans les journaux, vous verrez des messages semblables à ceux-ci:
Container storage usage of worker reached 155.7% of the limit.
This likely means that the total size of local files generated by your DAGs is
close to the storage limit of worker.
You may need to decrease the storage usage or increase the worker storage limit
in your Cloud Composer environment configuration.
ou
Pod storage usage of worker reached 140.2% of the limit.
A worker pod was evicted at 2023-12-01T12:30:05Z with message: Pod ephemeral
local storage usage exceeds the total limit of containers 1023Mi.
This eviction likely means that the total size of dags and plugins folders plus
local files generated by your DAGs exceeds the storage limit of worker.
Please decrease the storage usage or increase the worker storage limit in your
Cloud Composer environment configuration.
Ces messages indiquent qu'au fur et à mesure de la progression de la tâche, les journaux Airflow ont commencé à imprimer des erreurs lorsque la taille des fichiers générés par votre DAG a dépassé la limite de stockage du nœud de calcul et que le délai de grâce pour la résiliation a commencé. Pendant le délai de grâce pour la résiliation, l'utilisation du stockage n'a pas retrouvé sa limite, ce qui a entraîné l'éviction du pod à la fin du délai de grâce pour la résiliation.
Examinez la surveillance de l'état de l'environnement et de la consommation des ressources:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Surveillance, puis sélectionnez Présentation.
Dans le panneau Présentation de l'environnement, localisez le graphique État de l'environnement (DAG de surveillance Airflow). Il contient une zone rouge, qui correspond à l'heure à laquelle les journaux ont commencé à imprimer des erreurs.
Sélectionnez Nœuds de calcul, puis recherchez le graphique Utilisation totale du disque par les nœuds de calcul. Notez que la ligne Utilisation du disque présente un pic et dépasse la ligne Limite de disque au moment de l'exécution de votre tâche.
![La ligne d'utilisation du disque présente un pic et dépasse la limite de disque au moment de l'exécution de votre tâche](https://cloud.google.com/static/composer/docs/images/composer-workers-disk-usage.png?authuser=7&hl=fr)
Augmenter la limite de stockage des nœuds de calcul
Allouez un espace de stockage supplémentaire aux nœuds de calcul Airflow pour que l'exemple de DAG aboutisse:
Dans la console Google Cloud, accédez à la page Environnements.
Dans la liste des environnements, cliquez sur le nom de votre environnement. La page Détails de l'environnement s'ouvre.
Accédez à l'onglet Configuration de l'environnement.
Accédez à Resources > Workloads (Ressources > Configuration des charges de travail), puis cliquez sur Edit (Modifier).
Dans le champ Stockage de la section Nœud de calcul, spécifiez la nouvelle limite de stockage pour les nœuds de calcul Airflow. Dans ce tutoriel, définissez-la sur 2 Go.
Enregistrez les modifications et attendez quelques minutes pour que vos nœuds de calcul Airflow redémarrent.
Tester votre DAG avec la nouvelle limite de stockage
Déclenchez à nouveau le DAG long_running_create_large_txt_file_print_logs
et attendez la fin de son exécution pendant 1 heure et 15 minutes.
Dans les journaux de sortie de l'exécution de votre DAG, vous verrez
Marking task as SUCCESS
et l'état de la tâche indiquera Success (Opération réussie) avec une durée de 1 heure et 15 minutes égale au temps d'attente défini dans le code du DAG.Consultez la section Présentation de l'environnement dans l'onglet Surveillance et vérifiez qu'il n'y a pas de zone rouge.
Cliquez sur la section Nœuds de calcul et recherchez le graphique Utilisation totale du disque par les nœuds de calcul. La ligne Limite de disque indique la modification de la limite de stockage et la ligne Utilisation du disque se situe dans la plage autorisée.
Résumé
Dans ce tutoriel, vous avez diagnostiqué la cause d'un échec de DAG et identifié le type de ressource à l'origine de la pression en déboguant deux exemples de DAG qui échouent en raison d'un manque de mémoire et de stockage des nœuds de calcul. Vous avez ensuite exécuté les DAG correctement après avoir alloué de la mémoire et de l'espace de stockage supplémentaires à vos nœuds de calcul. Toutefois, il est recommandé d'optimiser vos DAG (workflows) afin de réduire la consommation des ressources des nœuds de calcul, car il est impossible d'augmenter les ressources au-delà d'un certain seuil.
Effectuer un nettoyage
Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.
Supprimer le projet
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
Supprimer des ressources individuelles
Si vous envisagez d'explorer plusieurs tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.
Supprimez l'environnement Cloud Composer. Vous allez également supprimer le bucket de l'environnement au cours de cette procédure.
Étapes suivantes
- Faire évoluer des environnements
- Découvrez comment résoudre les problèmes liés aux DAG.