Cloud Composer 1 | Cloud Composer 2 | Cloud Composer 3
Cette page explique comment créer un environnement Cloud Composer.
- Pour en savoir plus sur les environnements, consultez la section Architecture des environnements.
- Pour en savoir plus sur la création d'un environnement avec Terraform, consultez Créer des environnements (Terraform).
Avant de commencer
Activez l'API Cloud Composer. Pour obtenir la liste complète des services utilisés par Cloud Composer, consultez la section Services requis par Cloud Composer.
La durée approximative de création d'un environnement est de 25 minutes.
Lors de la création de l'environnement, vous spécifiez un compte de service. Cloud Composer lie ce compte à un compte de service Kubernetes du cluster de votre environnement.
Par défaut, les environnements Cloud Composer utilisent le compte de service Compute Engine par défaut géré par Google. Nous vous recommandons de créer un compte de service géré par l'utilisateur disposant d'un rôle spécifique à Cloud Composer et de l'utiliser pour vos environnements.
Si vous créez un environnement avec Terraform, le compte de service utilisé par Terraform doit disposer d'un rôle avec l'autorisation
composer.environments.create
activée.Pour en savoir plus sur le compte de service pour Terraform, consultez la documentation de référence sur la configuration du fournisseur Google.
Pour en savoir plus sur l'utilisation de Terraform pour créer un environnement Cloud Composer, consultez la documentation Terraform.
Pour en savoir plus sur les paramètres supplémentaires, consultez la documentation de référence sur les arguments Terraform.
VPC SC : pour déployer des environnements Cloud Composer dans un périmètre de sécurité, consultez la section Configurer VPC SC. Lorsque vous utilisez Cloud Composer, VPC Service Controls applique plusieurs limites connues.
1. Configuration de base
Cette étape crée un environnement Cloud Composer avec des paramètres par défaut à l'emplacement spécifié.
Console
Dans la console Google Cloud, accédez à la page Créer un environnement.
Dans le champ Nom, saisissez le nom de l'environnement.
Le nom doit commencer par une lettre minuscule suivie d'un maximum de 62 caractères (lettres minuscules, chiffres ou traits d'union) et ne peut pas se terminer par un trait d'union. Le nom de l'environnement est utilisé pour créer des sous-composants pour l'environnement. Vous devez donc indiquer un nom également valide pour les buckets Cloud Storage. Pour obtenir une liste des restrictions, consultez la page Consignes de dénomination des buckets.
Dans la liste déroulante Emplacement, choisissez un emplacement pour votre environnement.
Un emplacement est la région dans laquelle se situe l'environnement.
Dans la liste déroulante Version de l'image, sélectionnez une image Cloud Composer avec la version requise d'Airflow.
gcloud
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version IMAGE_VERSION
Remplacez :
ENVIRONMENT_NAME
par le nom de l'environnement.Le nom doit commencer par une lettre minuscule suivie d'un maximum de 62 caractères (lettres minuscules, chiffres ou traits d'union) et ne peut pas se terminer par un trait d'union. Le nom de l'environnement est utilisé pour créer des sous-composants pour l'environnement. Vous devez donc indiquer un nom également valide pour les buckets Cloud Storage. Pour obtenir une liste des restrictions, consultez la page Consignes de dénomination des buckets.
LOCATION
par la région de l'environnement.Un emplacement est la région dans laquelle se situe l'environnement.
IMAGE_VERSION
par le nom d'une image Cloud Composer.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6
API
Rédigez une requête API environments.create
. Spécifiez la configuration dans la ressource Environment
.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"softwareConfig": {
"imageVersion": "IMAGE_VERSION"
}
}
}
Remplacez :
PROJECT_ID
par l'ID du projet.LOCATION
par la région de l'environnement.Un emplacement est la région dans laquelle se situe l'environnement.
ENVIRONMENT_NAME
par le nom de l'environnement.Le nom doit commencer par une lettre minuscule suivie d'un maximum de 62 caractères (lettres minuscules, chiffres ou traits d'union) et ne peut pas se terminer par un trait d'union. Le nom de l'environnement est utilisé pour créer des sous-composants pour l'environnement. Vous devez donc indiquer un nom également valide pour les buckets Cloud Storage. Pour obtenir une liste des restrictions, consultez la page Consignes de dénomination des buckets.
IMAGE_VERSION
par le nom d'une image Cloud Composer.
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"softwareConfig": {
"imageVersion": "composer-3-airflow-2.7.3-build.6"
}
}
}
Terraform
Pour créer un environnement avec des paramètres par défaut à un emplacement spécifié, ajoutez le bloc de ressources suivant à votre configuration Terraform, puis exécutez terraform apply
.
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
software_config {
image_version = "IMAGE_VERSION"
}
}
}
Remplacez :
ENVIRONMENT_NAME
par le nom de l'environnement.Le nom doit commencer par une lettre minuscule suivie d'un maximum de 62 caractères (lettres minuscules, chiffres ou traits d'union) et ne peut pas se terminer par un trait d'union. Le nom de l'environnement est utilisé pour créer des sous-composants pour l'environnement. Vous devez donc indiquer un nom également valide pour les buckets Cloud Storage. Pour obtenir une liste des restrictions, consultez la page Consignes de dénomination des buckets.
LOCATION
par la région de l'environnement.Un emplacement est la région dans laquelle se situe l'environnement.
IMAGE_VERSION
par le nom d'une image Cloud Composer.
Exemple :
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
config {
software_config {
image_version = "composer-3-airflow-2.7.3-build.6"
}
}
}
Étape 2. (Facultatif) Sélectionnez un compte de service pour votre environnement.
Cloud Composer lie ce compte de service au compte de service Kubernetes de votre environnement. Les nœuds du cluster de votre environnement s'exécutent en tant que compte de service Kubernetes et utilisent les liaisons pour accéder aux ressources de votre projet Google Cloud, telles que les fichiers de définition de DAG dans le bucket de votre environnement.
Par défaut, les environnements Cloud Composer utilisent le compte de service Compute Engine par défaut. Nous vous recommandons de configurer un compte de service géré par l'utilisateur pour les environnements Cloud Composer.
Vous ne pourrez pas modifier le compte de service de votre environnement ultérieurement.
Console
Sur la page Créer un environnement, dans la liste déroulante Compte de service, sélectionnez un compte de service pour votre environnement.
gcloud
Lorsque vous créez un environnement, l'argument --service-account
spécifie le compte de service de votre environnement.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--service-account "SERVICE_ACCOUNT"
Remplacez :
SERVICE_ACCOUNT
par le compte de service de votre environnement.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--service-account "example-account@example-project.iam.gserviceaccount.com"
API
Lorsque vous créez un environnement, spécifiez un compte de service pour votre environnement dans la ressource Environment > EnvironmentConfig.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"nodeConfig": {
"serviceAccount": "SERVICE_ACCOUNT"
}
}
Remplacez :
SERVICE_ACCOUNT
par le compte de service de votre environnement.
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"nodeConfig": {
"serviceAccount": "example-account@example-project.iam.gserviceaccount.com"
}
}
}
Terraform
Lorsque vous créez un environnement, utilisez le champ service_account
dans le bloc node_config
.
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
node_config {
service_account = "SERVICE_ACCOUNT"
}
}
}
Remplacez :
SERVICE_ACCOUNT
par le compte de service de votre environnement.
Exemple :
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
config {
node_config {
service_account = "example-account@example-project.iam.gserviceaccount.com"
}
}
}
Étape 3 : (Facultatif) Configurer les paramètres de scaling et de performances de l'environnement
Pour spécifier la configuration de scaling et de performances de votre environnement, sélectionnez la taille de l'environnement et la configuration des charges de travail.
Vous pouvez modifier tous les paramètres de performances et de scaling après avoir créé un environnement.
Les paramètres suivants contrôlent le scaling et les performances :
Taille de l'environnement Contrôle les paramètres de performances de l'infrastructure Cloud Composer gérée qui inclut la base de données Airflow. Envisagez de choisir une taille d'environnement plus importante si vous souhaitez exécuter un grand nombre de DAG et de tâches.
Configuration des charges de travail. Contrôle l'évolutivité et les performances des composants d'environnement qui s'exécutent dans un cluster GKE: programmeurs Airflow, serveur Web Airflow et nœuds de calcul Airflow.
Planificateur Airflow Analyse les fichiers de définition du DAG, planifie l'exécution du DAG en fonction de l'intervalle de programmation et met en file d'attente les tâches que les nœuds de calcul Airflow exécuteront.
Votre environnement peut exécuter plusieurs programmeurs Airflow à la fois. Utilisez plusieurs programmeurs pour répartir la charge entre les instances de programmeur, et ainsi améliorer les performances et la fiabilité.
L'augmentation du nombre de programmeurs n'améliore pas toujours les performances d'Airflow. Par exemple, le fait d'avoir un seul programmeur peut offrir de meilleures performances que deux. C'est le cas lorsque le programmeur supplémentaire n'est pas utilisé et consomme donc les ressources de votre environnement sans incidence sur les performances globales. Les performances réelles du programmeur dépendent du nombre de nœuds de calcul Airflow, du nombre de DAG et des tâches exécutées dans votre environnement, ainsi que de la configuration d'Airflow et de l'environnement.
Nous vous recommandons de commencer par deux programmeurs, puis de surveiller les performances de votre environnement. Si vous modifiez le nombre de programmeurs, vous pouvez toujours rétablir l'échelle du nombre de programmeurs d'origine de votre environnement.
Pour en savoir plus sur la configuration de plusieurs programmeurs, consultez la documentation Airflow.
Déclencheur Airflow. Surveille de manière asynchrone toutes les tâches différées de votre environnement. Si votre environnement comporte au moins une instance de déclencheur (ou au moins deux dans les environnements hautement résilients), vous pouvez utiliser des opérateurs différables dans vos DAG.
Processeur DAG Airflow. Il traite les fichiers DAG et les transforme en objets DAG. Dans Cloud Composer 3, cette partie du programmeur s'exécute en tant que composant d'environnement distinct.
Serveur Web Airflow. Exécute l'interface Web d'Airflow où vous pouvez surveiller, gérer et visualiser vos DAG.
Nœuds de calcul Airflow. Exécuter des tâches planifiées par les programmeurs Airflow Le nombre minimal et maximal de nœuds de calcul de votre environnement change de façon dynamique en fonction du nombre de tâches de la file d'attente.
Console
Vous pouvez sélectionner un préréglage pour votre environnement. Lorsque vous sélectionnez un préréglage, les paramètres de scaling et de performances de ce préréglage sont automatiquement sélectionnés. Vous avez également la possibilité de sélectionner un préréglage prédéfini personnalisé et de spécifier tous les paramètres d'évolutivité et de performances de votre environnement.
Pour sélectionner la configuration de scaling et de performances de votre environnement, sur la page Créer un environnement :
Pour utiliser des valeurs prédéfinies, dans la section Ressources de l'environnement, cliquez sur Petites, Moyennes ou Grandes.
Pour spécifier des valeurs personnalisées pour les paramètres de scaling et de performances, procédez comme suit :
Dans la section Ressources d'environnement, cliquez sur Personnalisées.
Dans la section Scheduler (Programmeur), définissez le nombre de programmeurs que vous souhaitez utiliser, ainsi que l'allocation des ressources pour leur processeur, leur mémoire et leur stockage.
Dans la section Déclencheur, utilisez le champ Nombre de déclencheurs pour saisir le nombre de déclencheurs dans votre environnement. Vous pouvez définir ce nombre sur 0 si vous ne souhaitez pas utiliser d'opérateurs différables dans vos DAG.
Si vous définissez au moins un déclencheur pour votre environnement, utilisez les champs Processeur et Mémoire afin de configurer l'allocation de ressources pour vos déclencheurs.
Dans la section Processeur DAG, spécifiez le nombre de processeurs DAG dans votre environnement, ainsi que la quantité de processeurs, de mémoire et d'espace de stockage pour chaque processeur DAG.
Dans la section Serveur Web, spécifiez la quantité de processeurs, de mémoire et d'espace de stockage pour le serveur Web.
Dans la section Worker, spécifiez les éléments suivants:
- Nombre minimal et maximal de nœuds de calcul pour les limites d'autoscaling dans votre environnement.
- Allocation du processeur, de la mémoire et du stockage pour vos nœuds de calcul
Dans la section Infrastructure de base, dans la liste déroulante Taille de l'environnement, sélectionnez la taille de l'environnement.
gcloud
Lorsque vous créez un environnement, les arguments suivants contrôlent les paramètres d'échelle et de performances de votre environnement.
--environment-size
spécifie la taille de l'environnement.--scheduler-count
spécifie le nombre de programmeurs.--scheduler-cpu
spécifie le nombre de processeurs pour un programmeur Airflow.--scheduler-memory
spécifie la quantité de mémoire pour un programmeur Airflow.--scheduler-storage
spécifie la quantité d'espace disque pour un programmeur Airflow.--triggerer-count
spécifie le nombre de déclencheurs Airflow dans votre environnement. La valeur par défaut de cette option est0
. Vous avez besoin de déclencheurs si vous souhaitez utiliser des opérateurs différables dans vos DAG.- Pour les environnements de résilience standards, utilisez une valeur comprise entre
0
et10
. - Pour les environnements hautement résilients, utilisez
0
ou une valeur comprise entre2
et10
.
- Pour les environnements de résilience standards, utilisez une valeur comprise entre
--triggerer-cpu
spécifie le nombre de processeurs pour un déclencheur Airflow, en unités de vCPU. Valeurs autorisées:0.5
,0.75
,1
. La valeur par défaut est0.5
.--triggerer-memory
spécifie la quantité de mémoire en Go pour un déclencheur Airflow. La valeur par défaut est0.5
.La mémoire minimale requise est égale au nombre de processeurs alloués aux déclencheurs. La valeur maximale autorisée est égale au nombre de processeurs déclencheurs, multiplié par 6,5.
Par exemple, si vous définissez l'option
--triggerer-cpu
sur1
, la valeur minimale de--triggerer-memory
est1
et la valeur maximale est6.5
.--dag-processor-cpu
spécifie le nombre de processeurs pour le processeur DAG.--dag-processor-memory
spécifie la quantité de mémoire pour le processeur DAG.--dag-processor-storage
spécifie la quantité d'espace disque pour le processeur DAG.--web-server-cpu
spécifie le nombre de processeurs pour le serveur Web Airflow.--web-server-memory
spécifie la quantité de mémoire pour le serveur Web Airflow.--web-server-storage
spécifie la quantité d'espace disque pour le serveur Web Airflow.--worker-cpu
spécifie le nombre de processeurs pour un nœud de calcul Airflow.--worker-memory
spécifie la quantité de mémoire pour un nœud de calcul Airflow.--worker-storage
spécifie la quantité d'espace disque pour un nœud de calcul Airflow.--min-workers
spécifie le nombre minimal de nœuds de calcul Airflow. Le cluster de votre environnement exécute au moins ce nombre de nœuds de calcul.--max-workers
spécifie le nombre maximal de nœuds de calcul Airflow. Le cluster de votre environnement exécute au maximum ce nombre de nœuds de calcul.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--environment-size ENVIRONMENT_SIZE \
--scheduler-count SCHEDULER_COUNT \
--scheduler-cpu SCHEDULER_CPU \
--scheduler-memory SCHEDULER_MEMORY \
--scheduler-storage SCHEDULER_STORAGE \
--triggerer-count TRIGGERER_COUNT \
--triggerer-cpu TRIGGERER_CPU \
--triggerer-memory TRIGGERER_MEMORY \
--dag-processor-cpu DAG_PROCESSOR_CPU \
--dag-processor-memory DAG_PROCESSOR_MEMORY \
--dag-processor-storage DAG_PROCESSOR_STORAGE \
--web-server-cpu WEB_SERVER_CPU \
--web-server-memory WEB_SERVER_MEMORY \
--web-server-storage WEB_SERVER_STORAGE \
--worker-cpu WORKER_CPU \
--worker-memory WORKER_MEMORY \
--worker-storage WORKER_STORAGE \
--min-workers WORKERS_MIN \
--max-workers WORKERS_MAX
Remplacez :
ENVIRONMENT_SIZE
parsmall
,medium
oularge
.SCHEDULER_COUNT
par le nombre de programmeurs.SCHEDULER_CPU
par le nombre de processeurs pour un programmeur, en unités de processeur virtuel.SCHEDULER_MEMORY
par la quantité de mémoire pour un programmeur.SCHEDULER_STORAGE
par l'espace disque pour un programmeur.TRIGGERER_COUNT
par le nombre de déclencheurs.TRIGGERER_CPU
par le nombre de processeurs pour un déclencheur, en unités de vCPU.TRIGGERER_MEMORY
par la quantité de mémoire pour un déclencheur, en Go.DAG_PROCESSOR_CPU
par le nombre de processeurs pour le processeur DAG.DAG_PROCESSOR_MEMORY
par la quantité de mémoire destinée au processeur DAG.DAG_PROCESSOR_STORAGE
par la quantité d'espace disque disponible pour le processeur DAG.WEB_SERVER_CPU
par le nombre de processeurs pour le serveur Web, en unités de processeur virtuel.WEB_SERVER_MEMORY
par l'espace disque pour le serveur Web.WEB_SERVER_STORAGE
par l'espace disque pour le serveur Web.WORKER_CPU
par le nombre de processeurs pour un nœud de calcul, en unités de processeur virtuel.WORKER_MEMORY
par la quantité de mémoire pour un nœud de calcul.WORKER_STORAGE
par l'espace disque pour un nœud de calcul.WORKERS_MIN
par le nombre minimal de nœuds de calcul Airflow que votre environnement doit exécuter. Le nombre de nœuds de calcul dans votre environnement ne dépasse pas cette valeur, même si un nombre inférieur de nœuds de calcul peut gérer la charge.WORKERS_MAX
par le nombre maximal de nœuds de calcul Airflow que votre environnement peut exécuter. Le nombre de nœuds de calcul dans votre environnement ne dépasse jamais cette valeur, même si un nombre plus élevé de nœuds de calcul est nécessaire pour gérer la charge.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--environment-size small \
--scheduler-count 1 \
--scheduler-cpu 0.5 \
--scheduler-memory 2.5GB \
--scheduler-storage 2GB \
--triggerer-count 1 \
--triggerer-cpu 0.5 \
--triggerer-memory 0.5GB \
--dag-processor-cpu 0.5 \
--dag-processor-memory 2GB \
--dag-processor-storage 1GB \
--web-server-cpu 1 \
--web-server-memory 2.5GB \
--web-server-storage 2GB \
--worker-cpu 1 \
--worker-memory 2GB \
--worker-storage 2GB \
--min-workers 2 \
--max-workers 4
API
Lorsque vous créez un environnement, dans la ressource Environment > EnvironmentConfig > WorkloadsConfig, spécifiez l'échelle et les paramètres de performances de l'environnement.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"workloadsConfig": {
"scheduler": {
"cpu": SCHEDULER_CPU,
"memoryGb": SCHEDULER_MEMORY,
"storageGb": SCHEDULER_STORAGE,
"count": SCHEDULER_COUNT
},
"triggerer": {
"count": TRIGGERER_COUNT,
"cpu": TRIGGERER_CPU,
"memoryGb": TRIGGERER_MEMORY
},
"dagProcessor": {
"count": 1,
"cpu": DAG_PROCESSOR_CPU,
"memoryGb": DAG_PROCESSOR_MEMORY,
"storageGb": DAG_PROCESSOR_STORAGE
},
"webServer": {
"cpu": WEB_SERVER_CPU,
"memoryGb": WEB_SERVER_MEMORY,
"storageGb": WEB_SERVER_STORAGE
},
"worker": {
"cpu": WORKER_CPU,
"memoryGb": WORKER_MEMORY,
"storageGb": WORKER_STORAGE,
"minCount": WORKERS_MIN,
"maxCount": WORKERS_MAX
}
},
"environmentSize": "ENVIRONMENT_SIZE"
}
}
Remplacez :
SCHEDULER_CPU
par le nombre de processeurs pour un programmeur, en unités de processeur virtuel.SCHEDULER_MEMORY
par la quantité de mémoire pour un programmeur, en Go.SCHEDULER_STORAGE
par l'espace disque pour un programmeur, en GoSCHEDULER_COUNT
par le nombre de programmeurs ;TRIGGERER_COUNT
par le nombre de déclencheurs. La valeur par défaut est0
. Vous avez besoin de déclencheurs si vous souhaitez utiliser des opérateurs différables dans vos DAG.- Pour les environnements de résilience standards, utilisez une valeur comprise entre
0
et10
. - Pour les environnements hautement résilients, utilisez
0
ou une valeur comprise entre2
et10
.
Si vous utilisez au moins un déclencheur, vous devez également spécifier les paramètres
TRIGGERER_CPU
etTRIGGERER_MEMORY
:- Pour les environnements de résilience standards, utilisez une valeur comprise entre
TRIGGERER_CPU
spécifie le nombre de processeurs pour un déclencheur, en unités de processeur virtuel. Valeurs autorisées:0.5
,0.75
,1
.TRIGGERER_MEMORY
configure la quantité de mémoire pour un déclencheur. La mémoire minimale requise est égale au nombre de processeurs alloués aux déclencheurs. La valeur maximale autorisée est égale au nombre de processeurs de déclencheur multiplié par 6,5.Par exemple, si vous définissez
TRIGGERER_CPU
sur1
, la valeur minimale deTRIGGERER_MEMORY
est1
et la valeur maximale est6.5
.DAG_PROCESSOR_CPU
par le nombre de processeurs pour le processeur DAG, en unités de processeur virtuel.DAG_PROCESSOR_MEMORY
par la quantité de mémoire destinée au processeur DAG, en Go.DAG_PROCESSOR_STORAGE
par la quantité d'espace disque disponible pour le processeur DAG, en Go.WEB_SERVER_CPU
par le nombre de processeurs pour le serveur Web, en unités de processeur virtuel.WEB_SERVER_MEMORY
par la quantité de mémoire pour le serveur Web, en Go.WEB_SERVER_STORAGE
par l'espace disque pour le serveur Web, en Go.WORKER_CPU
par le nombre de processeurs pour un nœud de calcul, en unités de processeur virtuel.WORKER_MEMORY
par la quantité de mémoire pour un nœud de calcul, en Go.WORKER_STORAGE
par l'espace disque pour un nœud de calcul, en Go.WORKERS_MIN
par le nombre minimal de nœuds de calcul Airflow que votre environnement doit exécuter. Le nombre de nœuds de calcul dans votre environnement ne dépasse pas cette valeur, même si un nombre inférieur de nœuds de calcul peut gérer la charge.WORKERS_MAX
par le nombre maximal de nœuds de calcul Airflow que votre environnement peut exécuter. Le nombre de nœuds de calcul dans votre environnement ne dépasse jamais cette valeur, même si un nombre plus élevé de nœuds de calcul est nécessaire pour gérer la charge.ENVIRONMENT_SIZE
par la taille de l'environnement,ENVIRONMENT_SIZE_SMALL
,ENVIRONMENT_SIZE_MEDIUM
ouENVIRONMENT_SIZE_LARGE
.
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"workloadsConfig": {
"scheduler": {
"cpu": 2.5,
"memoryGb": 2.5,
"storageGb": 2,
"count": 1
},
"triggerer": {
"cpu": 0.5,
"memoryGb": 0.5,
"count": 1
},
"dagProcessor": {
"count": 1,
"cpu": 0.5,
"memoryGb": 2,
"storageGb": 1
},
"webServer": {
"cpu": 1,
"memoryGb": 2.5,
"storageGb": 2
},
"worker": {
"cpu": 1,
"memoryGb": 2,
"storageGb": 2,
"minCount": 2,
"maxCount": 4
}
},
"environmentSize": "ENVIRONMENT_SIZE_SMALL"
}
}
Terraform
Lorsque vous créez un environnement, les arguments suivants contrôlent les paramètres de scaling et de performances de votre environnement.
Dans le bloc
config
:- Le champ
environment_size
contrôle la taille de l'environnement.
- Le champ
Dans le bloc
workloads_config
:- Le champ
scheduler.cpu
spécifie le nombre de processeurs pour un programmeur Airflow. - Le champ
scheduler.memory_gb
spécifie la quantité de mémoire pour un programmeur Airflow. - Le champ
scheduler.storage_gb
spécifie la quantité d'espace disque pour un programmeur Airflow. - Le champ
scheduler.count
indique le nombre de programmeurs dans votre environnement. - Le champ
triggerer.cpu
indique le nombre de processeurs pour un déclencheur Airflow. - Le champ
triggerer.memory_gb
spécifie la quantité de mémoire pour un déclencheur Airflow. Le champ
triggerer.count
indique le nombre de déclencheurs dans votre environnement.Le champ
dag_processor.cpu
indique le nombre de processeurs pour un processeur DAG.Le champ
dag_processor.memory_gb
spécifie la quantité de mémoire pour un processeur DAG.Le champ
dag_processor.storage_gb
spécifie la quantité d'espace disque pour un processeur DAG.Le champ
dag_processor.count
indique le nombre de processeurs DAG.Le champ
web_server.cpu
spécifie le nombre de processeurs pour le serveur Web Airflow.Le champ
web_server.memory_gb
spécifie la quantité de mémoire pour le serveur Web Airflow.Le champ
web_server.storage_gb
spécifie la quantité d'espace disque pour le serveur Web Airflow.Le champ
worker.cpu
spécifie le nombre de processeurs pour un nœud de calcul Airflow.Le champ
worker.memory_gb
spécifie la quantité de mémoire pour un nœud de calcul Airflow.Le champ
worker.storage_gb
spécifie la quantité d'espace disque pour un nœud de calcul Airflow.Le champ
worker.min_count
spécifie le nombre minimal de nœuds de calcul dans votre environnement.Le champ
worker.max_count
spécifie le nombre maximal de nœuds de calcul dans votre environnement.
- Le champ
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
workloads_config {
scheduler {
cpu = SCHEDULER_CPU
memory_gb = SCHEDULER_MEMORY
storage_gb = SCHEDULER_STORAGE
count = SCHEDULER_COUNT
}
triggerer {
count = TRIGGERER_COUNT
cpu = TRIGGERER_CPU
memory_gb = TRIGGERER_MEMORY
}
web_server {
cpu = WEB_SERVER_CPU
memory_gb = WEB_SERVER_MEMORY
storage_gb = WEB_SERVER_STORAGE
}
worker {
cpu = WORKER_CPU
memory_gb = WORKER_MEMORY
storage_gb = WORKER_STORAGE
min_count = WORKERS_MIN
max_count = WORKERS_MAX
}
}
environment_size = "ENVIRONMENT_SIZE"
}
}
Remplacez :
ENVIRONMENT_NAME
par le nom de l'environnement.LOCATION
par la région dans laquelle se trouve l'environnement.SCHEDULER_CPU
par le nombre de processeurs pour un programmeur, en unités de processeur virtuel.SCHEDULER_MEMORY
par la quantité de mémoire pour un programmeur, en Go.SCHEDULER_STORAGE
par l'espace disque pour un programmeur, en GoSCHEDULER_COUNT
par le nombre de programmeurs ;TRIGGERER_COUNT
par le nombre de déclencheurs.TRIGGERER_CPU
par le nombre de processeurs pour un déclencheur, en unités de vCPU.TRIGGERER_MEMORY
par la quantité de mémoire pour un déclencheur, en Go.WEB_SERVER_CPU
par le nombre de processeurs pour le serveur Web, en unités de processeur virtuel.WEB_SERVER_MEMORY
par la quantité de mémoire pour le serveur Web, en Go.WEB_SERVER_STORAGE
par l'espace disque pour le serveur Web, en Go.WORKER_CPU
par le nombre de processeurs pour un nœud de calcul, en unités de processeur virtuel.WORKER_MEMORY
par la quantité de mémoire pour un nœud de calcul, en Go.WORKER_STORAGE
par l'espace disque pour un nœud de calcul, en Go.WORKERS_MIN
par le nombre minimal de nœuds de calcul Airflow que votre environnement doit exécuter. Le nombre de nœuds de calcul dans votre environnement ne dépasse pas cette valeur, même si un nombre inférieur de nœuds de calcul peut gérer la charge.WORKERS_MAX
par le nombre maximal de nœuds de calcul Airflow que votre environnement peut exécuter. Le nombre de nœuds de calcul dans votre environnement ne dépasse jamais cette valeur, même si un nombre plus élevé de nœuds de calcul est nécessaire pour gérer la charge.ENVIRONMENT_SIZE
par la taille de l'environnement,ENVIRONMENT_SIZE_SMALL
,ENVIRONMENT_SIZE_MEDIUM
ouENVIRONMENT_SIZE_LARGE
.
Exemple :
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
config {
workloads_config {
scheduler {
cpu = 2.5
memory_gb = 2.5
storage_gb = 2
count = 1
}
triggerer {
count = 1
cpu = 0.5
memory_gb = 0.5
}
web_server {
cpu = 1
memory_gb = 2.5
storage_gb = 2
}
worker {
cpu = 1
memory_gb = 2
storage_gb = 2
min_count = 2
max_count = 4
}
}
environment_size = "ENVIRONMENT_SIZE_SMALL"
}
}
Étape 4. (Facultatif) Spécifiez une zone pour la base de données de l'environnement
Vous pouvez spécifier une zone Cloud SQL préférée pour votre environnement.
Console
Sur la page Créer un environnement :
Dans la section Configuration avancée, développez l'élément Afficher la configuration avancée.
Dans la liste Zone de base de données Airflow, sélectionnez une zone Cloud SQL préférée.
gcloud
Lorsque vous créez un environnement, l'argument --cloud-sql-preferred-zone
spécifie une zone Cloud SQL préférée.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--cloud-sql-preferred-zone SQL_ZONE
Remplacez les éléments suivants :
SQL_ZONE
: zone Cloud SQL préférée. Cette zone doit être située dans la région dans laquelle se trouve l'environnement.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--cloud-sql-preferred-zone us-central1-a
API
Lorsque vous créez un environnement, spécifiez la zone Cloud SQL préférée dans la ressource Environment > DatabaseConfig.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"databaseConfig": {
"zone": "SQL_ZONE"
}
}
}
Remplacez les éléments suivants :
SQL_ZONE
: zone Cloud SQL préférée. Cette zone doit être située dans la région dans laquelle se trouve l'environnement.
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"databaseConfig": {
"zone": "us-central1-a"
}
}
}
Terraform
Lorsque vous créez un environnement, le champ zone
du bloc database_config
spécifie la zone Cloud SQL préférée.
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
database_config {
zone = "SQL_ZONE"
}
}
}
Remplacez les éléments suivants :
SQL_ZONE
: zone Cloud SQL préférée. Cette zone doit être située dans la région dans laquelle se trouve l'environnement.
Étape 5 : (Facultatif) Configurer la mise en réseau de votre environnement
Vous pouvez configurer la mise en réseau Cloud Composer 3 de différentes manières:
- Dans un environnement d'adresse IP publique, les composants Airflow de votre environnement peuvent accéder à Internet.
- Dans un environnement d'adresse IP privée, les composants Airflow de votre environnement n'ont pas accès à Internet.
- Les environnements IP privés et publics peuvent se connecter à votre réseau VPC comme option distincte.
- Vous pouvez spécifier la plage d'adresses IP internes de votre environnement. Vous ne pourrez pas modifier cette plage par la suite.
Vous pouvez activer l'accès à Internet lors de l'installation des packages PyPI. Par exemple, votre environnement IP privé peut toujours installer des packages PyPI à partir de l'index de packages Python si vous activez cette option.
Pour un environnement VPC partagé, vous devez effectuer une configuration réseau supplémentaire pour le projet hôte, puis créer un environnement d'adresse IP publique ou privée dans un projet de service. Suivez les instructions de la page Configurer un VPC partagé.
Console
Assurez-vous que votre mise en réseau est configurée pour le type d'environnement que vous souhaitez créer.
Dans la section Configuration du réseau, développez l'élément Afficher la configuration réseau.
Si vous souhaitez connecter votre environnement à un réseau VPC, sélectionnez un rattachement de réseau dans le champ Rattachement de réseau. Vous pouvez également créer un rattachement de réseau. Pour en savoir plus, consultez la page Connecter un environnement à un réseau VPC.
Si vous souhaitez créer un environnement IP privé, sélectionnez l'option Environnement IP privé dans la section Type de mise en réseau.
Si vous souhaitez ajouter des tags réseau, consultez Ajouter des tags réseau pour en savoir plus.
gcloud
Assurez-vous que votre mise en réseau est configurée pour le type d'environnement que vous souhaitez créer.
Lorsque vous créez un environnement, les arguments suivants contrôlent les paramètres de mise en réseau. Si vous omettez un paramètre, la valeur par défaut est utilisée.
--enable-private-environment
active un environnement d'adresse IP privée.--network
spécifie l'ID de votre réseau VPC.--subnetwork
spécifie l'ID de votre sous-réseau VPC.
--composer-internal-ipv4-cidr-block
spécifie la plage d'adresses IP internes de l'environnement. Cette plage est utilisée par Cloud Composer dans le projet locataire de votre environnement.
Exemple (environnement IP privé avec un réseau VPC connecté)
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--enable-private-environment \
--network NETWORK_ID \
--subnetwork SUBNETWORK_ID \
Remplacez :
NETWORK_ID
par votre ID de réseau VPC ;SUBNETWORK_ID
par votre ID de sous-réseau VPC ;
Étape 6 : (Facultatif) Ajouter des tags réseau
Les tags réseau sont appliqués à toutes les VM de nœud du cluster de votre environnement. Les tags permettent d'identifier les sources ou les cibles valides pour les pare-feu de réseau. Chaque tag de la liste doit être conforme au format RFC 1035.
Par exemple, vous pouvez ajouter des tags réseau si vous envisagez de restreindre le trafic d'un environnement IP privé avec des règles de pare-feu.
Console
Sur la page Créer un environnement :
- Accédez à la section Configuration du réseau.
- Dans le champ Tags réseau, saisissez les tags réseau de votre environnement.
gcloud
Lorsque vous créez un environnement, les arguments suivants contrôlent les tags réseau:
--tags
spécifie une liste de tags réseau séparés par une virgule et appliqués à toutes les VM de nœuds.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--tags TAGS
Remplacez :
TAGS
par une liste de tags réseau séparés par une virgule.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--tags group1,production
API
Lorsque vous créez un environnement, spécifiez les tags réseau de votre environnement dans la ressource Environment > EnvironmentConfig.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"nodeConfig": {
"tags": [
"TAG"
]
}
}
}
Remplacez :
TAG
par un tag réseau.
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"nodeConfig": {
"tags": [
"group1",
"production"
]
}
}
}
Terraform
Lorsque vous créez un environnement, les champs suivants définissent les tags réseau de votre environnement:
- Le champ
tags
du blocnode_config
spécifie une liste de tags réseau séparés par une virgule qui sont appliqués à toutes les VM de nœuds.
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
node_config {
tags = ["TAGS"]
}
}
}
Remplacez :
TAGS
par une liste de tags réseau séparés par une virgule.
Exemple :
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
config {
node_config {
tags = ["group1","production"]
}
}
}
Étape 7. (Facultatif) Configurer l'accès réseau au serveur Web
Les paramètres d'accès au serveur Web Airflow ne dépendent pas du type de votre environnement. Vous pouvez configurer l'accès au serveur Web séparément. Par exemple, un environnement d'adresse IP privée peut toujours laisser l'interface utilisateur d'Airflow accessible depuis Internet.
Vous ne pouvez pas configurer les plages d'adresses IP autorisées à l'aide d'adresses IP privées.
Console
Sur la page Créer un environnement :
Dans la section Configuration du réseau, développez l'élément Afficher la configuration du réseau.
Dans la section Contrôle de l'accès réseau au serveur Web :
Pour permettre l'accès au serveur Web Airflow à partir de toutes les adresses IP, sélectionnez Autoriser l'accès depuis toutes les adresses IP.
Pour limiter l'accès à des plages d'adresses IP spécifiques, sélectionnez Autoriser l'accès uniquement depuis des adresses IP spécifiques. Dans le champ Plage d'adresses IP, spécifiez une plage d'adresses IP au format CIDR. Dans le champ Description, spécifiez une description facultative pour cette plage. Si vous souhaitez spécifier plusieurs plages, cliquez sur Ajouter une plage d'adresses IP.
Pour refuser l'accès pour toutes les adresses IP, sélectionnez Autoriser l'accès uniquement depuis des adresses IP spécifiques, puis cliquez sur Supprimer l'élément à côté de l'entrée de plage vide.
gcloud
Lorsque vous créez un environnement, les arguments suivants contrôlent le niveau d'accès du serveur Web :
--web-server-allow-all
permet d'accéder à Airflow à partir de toutes les adresses IP. Il s'agit de l'option par défaut.--web-server-allow-ip
limite l'accès à des plages d'adresses IP sources spécifiques. Pour spécifier plusieurs plages d'adresses IP, utilisez cet argument plusieurs fois.--web-server-deny-all
interdit l'accès pour toutes les adresses IP.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--web-server-allow-ip ip_range=WS_IP_RANGE,description=WS_RANGE_DESCRIPTION
Remplacez :
WS_IP_RANGE
par la plage d'adresses IP, au format CIDR, pouvant accéder à l'interface utilisateur d'Airflow.WS_RANGE_DESCRIPTION
par la description de la plage d'adresses IP.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--web-server-allow-ip ip_range=192.0.2.0/24,description="office net 1" \
--web-server-allow-ip ip_range=192.0.4.0/24,description="office net 3"
API
Lorsque vous créez un environnement, spécifiez les paramètres d'accès au serveur Web dans la ressource Environment > EnvironmentConfig.
Pour permettre l'accès au serveur Web Airflow à partir de toutes les adresses IP, omettez
webServerNetworkAccessControl
.Pour limiter l'accès à des plages d'adresses IP spécifiques, spécifiez une ou plusieurs plages dans
allowedIpRanges
.Pour interdire l'accès pour toutes les adresses IP, ajoutez
allowedIpRanges
et faites-en une liste vide. Ne spécifiez pas de plages d'adresses IP.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"webServerNetworkAccessControl": {
"allowedIpRanges": [
{
"value": "WS_IP_RANGE",
"description": "WS_RANGE_DESCRIPTION"
}
]
}
}
}
Remplacez :
WS_IP_RANGE
par la plage d'adresses IP, au format CIDR, pouvant accéder à l'interface utilisateur d'Airflow.WS_RANGE_DESCRIPTION
par la description de la plage d'adresses IP.
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"webServerNetworkAccessControl": {
"allowedIpRanges": [
{
"value": "192.0.2.0/24",
"description": "office net 1"
},
{
"value": "192.0.4.0/24",
"description": "office net 3"
}
]
}
}
}
Terraform
Lorsque vous créez un environnement, le bloc allowed_ip_range
du bloc web_server_network_access_control
contient des plages d'adresses IP pouvant accéder au serveur Web.
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
web_server_network_access_control {
allowed_ip_range {
value = "WS_IP_RANGE"
description = "WS_RANGE_DESCRIPTION"
}
}
}
}
Remplacez :
WS_IP_RANGE
par la plage d'adresses IP, au format CIDR, pouvant accéder à l'interface utilisateur d'Airflow.WS_RANGE_DESCRIPTION
par la description de la plage d'adresses IP.
Exemple :
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
config {
web_server_network_access_control {
allowed_ip_range {
value = "192.0.2.0/24"
description = "office net 1"
},
allowed_ip_range {
value = "192.0.4.0/24"
description = "office net 3"
}
}
}
Étape 8 : Spécifier les remplacements de configuration Airflow et les variables d'environnement
Vous pouvez configurer des remplacements de configuration Airflow et des variables d'environnement lorsque vous créez un environnement. Vous pouvez également effectuer cette opération ultérieurement, après la création de votre environnement.
Remarque : Certaines options de configuration Airflow sont bloquées et vous ne pouvez pas les ignorer.
Pour obtenir la liste des options de configuration Airflow, consultez les pages Documentation de référence sur la configuration pour Airflow 2 et Airflow 1.10*.
Pour spécifier les remplacements de configuration Airflow et les variables d'environnement, procédez comme suit :
Console
Sur la page Créer un environnement :
Dans la section Variables d'environnement, cliquez sur Ajouter une variable.
Renseignez les champs Nom et Valeur de la variable d'environnement.
Dans la section Remplacements de configuration Airflow, cliquez sur Ajouter un remplacement de configuration Airflow.
Renseignez les champs Section, Clé et Valeur du remplacement de l'option de configuration.
Exemple :
Section Clé Valeur webserver
dag_orientation
TB
gcloud
Lorsque vous créez un environnement, les arguments suivants contrôlent les variables d'environnement et les remplacements de configuration Airflow :
--env-variables
spécifie une liste de variables d'environnement séparées par des virgules.Les noms des variables peuvent contenir des lettres majuscules et minuscules, des chiffres et des traits de soulignement, mais ils ne peuvent pas commencer par un chiffre.
--airflow-configs
spécifie une liste de clés et de valeurs séparées par une virgule pour les remplacements de configuration Airflow.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--env-variables ENV_VARS \
--airflow-configs CONFIG_OVERRIDES
Remplacez :
ENV_VARS
par une liste de pairesNAME=VALUE
séparées par des virgules pour les variables d'environnement ;CONFIG_OVERRIDES
par une liste de pairesSECTION-KEY=VALUE
séparées par des virgules pour les remplacements de configuration. Séparez le nom de la section de configuration par un symbole-
, suivi du nom de la clé. Exemple :core-dags_are_paused_at_creation
.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--env-variables SENDGRID_MAIL_FROM=user@example.com,SENDGRID_API_KEY=example-key \
--airflow-configs core-dags_are_paused_at_creation=True,webserver-dag_orientation=TB
API
Lorsque vous créez un environnement, spécifiez les variables d'environnement et les remplacements de configuration Airflow dans la ressource Environment > EnvironmentConfig.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"softwareConfig": {
"airflowConfigOverrides": {
"SECTION-KEY": "OVERRIDE_VALUE"
},
"envVariables": {
"VAR_NAME": "VAR_VALUE",
}
}
}
}
Remplacez :
SECTION
par la section du fichier de configuration où se trouve l'option de configuration Airflow ;KEY
par le nom de l'option de configuration Airflow ;OVERRIDE_VALUE
par la valeur de l'option de configuration Airflow ;VAR_NAME
par le nom de la variable d'environnement.VAR_VALUE
par la valeur de la variable d'environnement ;
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"softwareConfig": {
"airflowConfigOverrides": {
"core-dags_are_paused_at_creation": "True",
"webserver-dag_orientation": "TB"
},
"envVariables": {
"SENDGRID_MAIL_FROM": "user@example.com",
"SENDGRID_API_KEY": "example-key"
}
}
}
}
Terraform
Lorsque vous créez un environnement, les blocs suivants contrôlent les variables d'environnement et les remplacements de configuration Airflow :
Le bloc
env_variables
du blocsoftware_config
spécifie des variables d'environnement.Les noms des variables peuvent contenir des lettres majuscules et minuscules, des chiffres et des traits de soulignement, mais ils ne peuvent pas commencer par un chiffre.
Le bloc
airflow_config_overrides
du blocsoftware_config
spécifie les remplacements de configuration Airflow.
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
software_config {
airflow_config_overrides = {
SECTION-KEY = "OVERRIDE_VALUE"
}
env_variables = {
VAR_NAME = "VAR_VALUE"
}
}
}
}
Remplacez :
SECTION
par la section du fichier de configuration où se trouve l'option de configuration Airflow ;KEY
par le nom de l'option de configuration Airflow ;OVERRIDE_VALUE
par la valeur de l'option de configuration Airflow ;VAR_NAME
par le nom de la variable d'environnement.VAR_VALUE
par la valeur de la variable d'environnement ;
Exemple :
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
config {
software_config {
airflow_config_overrides = {
core-dags_are_paused_at_creation = "True"
webserver-dag_orientation = "TB"
}
env_variables = {
SENDGRID_MAIL_FROM = "user@example.com"
SENDGRID_API_KEY = "example-key"
}
}
}
}
Étape 9 : (Facultatif) Spécifier des intervalles de maintenance
Dans Cloud Composer 3, les intervalles de maintenance par défaut sont définis comme suit:
- Toutes les heures sont exprimées dans le fuseau horaire local de la région dans laquelle se trouve votre environnement, mais l'heure d'été est ignorée.
- Les intervalles de maintenance du mardi, mercredi, jeudi et vendredi sont de 00:00:00 à 02:00:00.
- Les intervalles de maintenance du samedi, du dimanche et du lundi sont compris entre 00:00:00 et 04:00:00.
Pour spécifier des intervalles de maintenance personnalisés pour votre environnement:
Console
Sur la page Créer un environnement
Accédez à la section Intervalles de maintenance.
Dans la liste déroulante Fuseau horaire, choisissez un fuseau horaire pour les intervalles de maintenance.
Définissez l'heure de début, les jours et la durée de manière à obtenir une planification équivalant au minimum à 12 heures sur une période glissante de sept jours. Par exemple, une périodicité de 4 heures tous les lundis, mercredis et vendredis fournit bien la durée requise.
gcloud
Les arguments suivants définissent les paramètres d'intervalles de maintenance :
--maintenance-window-start
définit l'heure de début d'un intervalle de maintenance.--maintenance-window-end
définit l'heure de fin d'un intervalle de maintenance.--maintenance-window-recurrence
définit la récurrence de l'intervalle de maintenance.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--maintenance-window-start 'DATETIME_START' \
--maintenance-window-end 'DATETIME_END' \
--maintenance-window-recurrence 'MAINTENANCE_RECURRENCE'
Remplacez :
ENVIRONMENT_NAME
par le nom de l'environnement.DATETIME_START
par la date et l'heure de début au format "date/heure". Seule l'heure spécifiée est utilisée, la date est ignorée.DATETIME_END
par la date et l'heure de fin au format "date/heure". Seule l'heure spécifiée est utilisée, la date est ignorée. La date et l'heure spécifiées doivent être postérieures à la date de début.MAINTENANCE_RECURRENCE
par une expression RRULE RFC 5545 pour la récurrence des intervalles de maintenance. Cloud Composer est compatible avec deux formats :Le format
FREQ=DAILY
indique une récurrence quotidienne.Le format
FREQ=WEEKLY;BYDAY=SU,MO,TU,WE,TH,FR,SA
indique une récurrence les jours sélectionnés de la semaine.
L'exemple suivant spécifie un intervalle de maintenance de six heures entre 01h00 et 07h00 (UTC) les mercredis, les samedis et les dimanches. La date du 1er janvier 2023 est ignorée.
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--maintenance-window-start '2023-01-01T01:00:00Z' \
--maintenance-window-end '2023-01-01T07:00:00Z' \
--maintenance-window-recurrence 'FREQ=WEEKLY;BYDAY=SU,WE,SA'
API
Lorsque vous créez un environnement, spécifiez les paramètres des intervalles de maintenance dans la ressource Environment > EnvironmentConfig:
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"config": {
"maintenanceWindow": {
"startTime": "DATETIME_START",
"endTime": "DATETIME_END",
"recurrence": "MAINTENANCE_RECURRENCE"
}
}
}
Remplacez :
DATETIME_START
par la date et l'heure de début au format "date/heure". Seule l'heure spécifiée est utilisée, la date est ignorée.DATETIME_END
par la date et l'heure de fin au format "date/heure". Seule l'heure spécifiée est utilisée, la date est ignorée. La date et l'heure spécifiées doivent être postérieures à la date de début.MAINTENANCE_RECURRENCE
par une expression RRULE RFC 5545 pour la récurrence des intervalles de maintenance. Cloud Composer est compatible avec deux formats :Le format
FREQ=DAILY
indique une récurrence quotidienne.Le format
FREQ=WEEKLY;BYDAY=SU,MO,TU,WE,TH,FR,SA
indique une récurrence les jours sélectionnés de la semaine.
L'exemple suivant spécifie un intervalle de maintenance de six heures entre 01h00 et 07h00 (UTC) les mercredis, les samedis et les dimanches. La date du 1er janvier 2023 est ignorée.
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"config": {
"maintenanceWindow": {
"startTime": "2023-01-01T01:00:00Z",
"endTime": "2023-01-01T07:00:00Z",
"recurrence": "FREQ=WEEKLY;BYDAY=SU,WE,SA"
}
}
}
Terraform
Le bloc maintenance_window
spécifie les intervalles de maintenance pour votre environnement:
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
config {
maintenance_window {
start_time = "DATETIME_START"
end_time = "DATETIME_END"
recurrence = "MAINTENANCE_RECURRENCE"
}
}
}
Remplacez :
DATETIME_START
par la date et l'heure de début au format "date/heure". Seule l'heure spécifiée est utilisée, la date est ignorée.DATETIME_END
par la date et l'heure de fin au format "date/heure". Seule l'heure spécifiée est utilisée, la date est ignorée. La date et l'heure spécifiées doivent être postérieures à la date de début.MAINTENANCE_RECURRENCE
par une expression RRULE RFC 5545 pour la récurrence des intervalles de maintenance. Cloud Composer est compatible avec deux formats :- Le format
FREQ=DAILY
indique une récurrence quotidienne. - Le format
FREQ=WEEKLY;BYDAY=SU,MO,TU,WE,TH,FR,SA
indique une récurrence les jours sélectionnés de la semaine.
- Le format
L'exemple suivant spécifie un intervalle de maintenance de six heures entre 01h00 et 07h00 (UTC) les mercredis, les samedis et les dimanches. La date du 1er janvier 2023 est ignorée.
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
config {
maintenance_window {
start_time = "2023-01-01T01:00:00Z"
end_time = "2023-01-01T07:00:00Z"
recurrence = "FREQ=WEEKLY;BYDAY=SU,WE,SA"
}
}
}
Étape 10 : (Facultatif) Intégration de la traçabilité des données
La traçabilité des données est une fonctionnalité Dataplex qui vous permet de suivre les mouvements de données.
L'intégration de la traçabilité des données est disponible dans toutes les versions de Cloud Composer 3.L'intégration de la traçabilité des données est automatiquement activée dans un nouvel environnement Cloud Composer si les conditions suivantes sont remplies:
L'API Data Lineage est activée dans votre projet. Pour en savoir plus, consultez la page Activer l'API Data Lineage dans la documentation Dataplex.
Aucun backend de traçabilité personnalisé n'est configuré dans Airflow.
Vous pouvez désactiver l'intégration de la traçabilité des données lorsque vous créez un environnement. Par exemple, si vous souhaitez ignorer le comportement automatique ou choisir d'activer la traçabilité des données ultérieurement, une fois l'environnement créé.
Console
Pour désactiver l'intégration de la traçabilité des données, sur la page Créer un environnement:
Dans la section Configuration avancée, développez l'élément Afficher la configuration avancée.
Dans la section Intégration de la traçabilité des données Dataplex, sélectionnez Désactiver l'intégration avec la traçabilité des données Dataplex.
gcloud
Lorsque vous créez un environnement, l'argument --disable-cloud-data-lineage-integration
désactive l'intégration de la traçabilité des données.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--disable-cloud-data-lineage-integration
Remplacez :
ENVIRONMENT_NAME
par le nom de l'environnement.LOCATION
par la région dans laquelle se trouve l'environnement.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--disable-cloud-data-lineage-integration
Étape 11 : (Facultatif) Configurer le chiffrement des données (CMEK)
Par défaut, les données de votre environnement sont chiffrées à l'aide d'une clé fournie par Google.
Pour utiliser des clés de chiffrement gérées par le client (CMEK) afin de chiffrer les données dans votre environnement, suivez les instructions de la page Utiliser des clés de chiffrement gérées par le client.
Étape 12 : (Facultatif) Utiliser le bucket d'un environnement personnalisé
Lorsque vous créez un environnement, Cloud Composer crée automatiquement un bucket pour votre environnement.
Vous pouvez également spécifier un bucket Cloud Storage personnalisé à partir de votre projet. Votre environnement utilise ce bucket de la même manière que le bucket créé automatiquement.
Pour utiliser un bucket d'environnement personnalisé, suivez les instructions décrites dans Utiliser un bucket d'environnement personnalisé.
Étape 13 : (Facultatif) Spécifier des libellés d'environnement
Vous pouvez attribuer des étiquettes à vos environnements pour décomposer les coûts facturés en fonction de ces étiquettes.
Console
Dans la section Libellés de la page Créer un environnement :
Cliquez sur Ajouter une étiquette.
Dans les champs Clé et Valeur, spécifiez des paires clé/valeur pour les libellés d'environnement.
gcloud
Lorsque vous créez un environnement, l'argument --labels
spécifie une liste de clés et de valeurs séparées par une virgule avec les libellés d'environnement.
gcloud composer environments create ENVIRONMENT_NAME \
--location LOCATION \
--image-version composer-3-airflow-2.7.3-build.6 \
--labels LABELS
Remplacez :
LABELS
par une liste de pairesKEY=VALUE
séparées par des virgules pour les variables d'environnement.
Exemple :
gcloud composer environments create example-environment \
--location us-central1 \
--image-version composer-3-airflow-2.7.3-build.6 \
--labels owner=engineering-team,env=production
API
Lorsque vous créez un environnement, dans la ressource Environnement, spécifiez des libellés pour votre environnement.
{
"name": "projects/PROJECT_ID/locations/LOCATION/environments/ENVIRONMENT_NAME",
"labels": {
"LABEL_KEY": "LABEL_VALUE"
}
}
Remplacez :
LABEL_KEY
par une clé de libellé d'environnement.LABEL_VALUE
par une valeur du libellé d'environnement
Exemple :
// POST https://composer.googleapis.com/v1/{parent=projects/*/locations/*}/environments
{
"name": "projects/example-project/locations/us-central1/environments/example-environment",
"labels": {
"owner": "engineering-team",
"env": "production"
}
}
Terraform
Lorsque vous créez un environnement, spécifiez des libellés dans le bloc labels
(en dehors du bloc config
).
resource "google_composer_environment" "example" {
provider = google-beta
name = "ENVIRONMENT_NAME"
region = "LOCATION"
labels = {
LABEL_KEY = "LABEL_VALUE"
}
}
Remplacez :
LABEL_KEY
par une clé de libellé d'environnement.LABEL_VALUE
par une valeur du libellé d'environnement
Exemple :
resource "google_composer_environment" "example" {
provider = google-beta
name = "example-environment"
region = "us-central1"
labels = {
owner = "engineering-team"
env = "production"
}
}
Étapes suivantes
- Résoudre les problèmes de création d'environnement
- Configurer un VPC partagé
- Configurer VPC Service Controls
- Ajouter et mettre à jour des DAG
- Accéder à l'interface utilisateur d'Airflow
- Mettre à jour et supprimer des environnements
- À propos des versions de Cloud Composer