Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Umgebungen upgraden

Auf dieser Seite wird beschrieben, wie Sie die Airflow-Version oder Cloud Composer-Version aktualisieren, die in Ihrer Umgebung ausgeführt wird.

Während des Upgrades führt Cloud Composer folgende Aufgaben aus:

  • Stellt den Airflow-Planer und die Worker-Pods in einem neuen Kubernetes-Namespace neu bereit. Nach Abschluss des Upgrades verwendet Airflow eine neue MySQL-Datenbank. Der Datenbankname stimmt mit dem Kubernetes-Namespace überein. Der DAG-Ausführungsverlauf wird beibehalten.

  • Die Airflow-airflow_db-Verbindung wird aktiviert, damit sie auf die neue Cloud SQL-Datenbank verweist.

Diese Änderungen wirken sich darauf aus, wie Sie auf Pods zugreifen und eine Verbindung zur Cloud SQL-Datenbank herstellen.

  • Für den Zugriff auf Pods im GKE-Cluster nach dem Upgrade sind Namespace-fähige kubectl-Befehle erforderlich. Zum Auflisten von Pods im Cluster verwenden Sie beispielsweise kubectl get pods -A. Für das Ausführen eines Befehls in einem Pod verwenden Sie kubectl exec -n <NAMESPACE> ....
  • Wenn Sie Airflow-Verbindungen und Arbeitslasten verwenden, die direkt auf den SQL-Proxy verweisen, geben Sie den Standard-Namespace in folgender Weise als Teil des Hostnamens an: airflow-sqlproxy-service.default, nicht airflow-sqlproxy-service.

Upgrades von Cloud Composer haben keinen Einfluss auf die Art und Weise, wie Sie eine Verbindung zu Ressourcen in Ihrer Umgebung herstellen: VM-IP-Adressen des Cloud Kubernetes Engine-Knotens, IP-Adressen der Cloud SQL-Instanz, Cloud Storage-Bucket oder Domainname des Airflow-Webservers.

Hinweis

  • Das Upgrade von Umgebungen befindet sich derzeit in der Vorschau. Verwenden Sie dieses Feature in Produktionsumgebungen mit Vorsicht.

  • Das Dienstkonto, das die Umgebung aktualisiert, oder ein Nutzerkonto, das die Aktualisierung auslöst, muss mindestens die Rolle Environment and Storage Object Administrator haben, wie unter Composer-Zugriffssteuerung beschrieben.

  • Beim Erstellen der Umgebung geben Sie ein Compute Engine-Dienstkonto oder ein benutzerdefiniertes Dienstkonto an, das die GKE-Knoten der Umgebung ausführt. Prüfen Sie, ob dieses Dienstkonto die folgenden Berechtigungen hat:

    • Für die Konfiguration einer öffentlichen IP-Adresse in Cloud Composer die Rollen Project Editor oder Composer Worker.

    • Für die Cloud Composer-Konfiguration Private IP, Project Editor- oder Composer Worker-Rollen und die Rolle iam.serviceAccountUser.

  • Halten Sie alle DAGs an und warten Sie, bis die laufenden Aufgaben abgeschlossen sind, bevor Sie ein Upgrade ausführen.

  • Sie können die Cloud Composer-Version, die Airflow-Version oder beide gleichzeitig upgraden.

  • Die Kombination aus Cloud Composer und Airflow, für die Sie ein Upgrade durchführen, muss eine veröffentlichte Version sein.

    • Informationen zu verfügbaren Upgrades finden Sie unter Verfügbare Upgrades aufrufen. Zum Abrufen der neuesten Features und Korrekturen ziehen Sie ein Upgrade auf die neueste Cloud Composer-Version in Betracht.
    • Eine Liste der PyPi-Pakete und -Anpassungen in einer unterstützten Version finden Sie in der Liste der Cloud Composer-Versionen.

      Bevor Sie das Upgrade durchführen, machen Sie sich mit den Unterschieden zwischen den aktuellen Versionen von Airflow und Cloud Composer vertraut. Inkompatible Änderungen können die ordnungsgemäße Ausführung der DAGs beeinträchtigen.

Airflow-Datenbankwartung

Die Airflow-Datenbank umfasst im Laufe der Zeit immer mehr Daten.

Mit diesem Wartungs-DAG können Sie den Inhalt Ihrer Datenbank bereinigen. Dieser DAG wird alten Einträgen aus den Tabellen von DagRun, TaskInstance, Log, XCom, Job DB und SlaMiss entfernt.

Datenbankwartungs-DAG

"""
A maintenance workflow that you can deploy into Airflow to periodically clean
out the DagRun, TaskInstance, Log, XCom, Job DB and SlaMiss entries to avoid
having too much data in your Airflow MetaStore.

## Authors

The DAG is a fork of [teamclairvoyant repository.](https://github.com/teamclairvoyant/airflow-maintenance-dags/tree/master/db-cleanup)

## Usage

1. Update the global variables (SCHEDULE_INTERVAL, DAG_OWNER_NAME,
  ALERT_EMAIL_ADDRESSES and ENABLE_DELETE) in the DAG with the desired values

2. Modify the DATABASE_OBJECTS list to add/remove objects as needed. Each
   dictionary in the list features the following parameters:
    - airflow_db_model: Model imported from airflow.models corresponding to
      a table in the airflow metadata database
    - age_check_column: Column in the model/table to use for calculating max
      date of data deletion
    - keep_last: Boolean to specify whether to preserve last run instance
        - keep_last_filters: List of filters to preserve data from deleting
          during clean-up, such as DAG runs where the external trigger is set to 0.
        - keep_last_group_by: Option to specify column by which to group the
          database entries and perform aggregate functions.

3. Create and Set the following Variables in the Airflow Web Server
  (Admin -> Variables)
    - airflow_db_cleanup__max_db_entry_age_in_days - integer - Length to retain
      the log files if not already provided in the conf. If this is set to 30,
      the job will remove those files that are 30 days old or older.

4. Put the DAG in your gcs bucket.
"""
from datetime import datetime, timedelta
import logging
import os

import airflow
from airflow import settings
from airflow.configuration import conf
from airflow.jobs import BaseJob
from airflow.models import DAG, DagModel, DagRun, Log, SlaMiss, \
    TaskInstance, Variable, XCom
from airflow.operators.python_operator import PythonOperator
import dateutil.parser
from sqlalchemy import and_, func
from sqlalchemy.exc import ProgrammingError
from sqlalchemy.orm import load_only

try:
    # airflow.utils.timezone is available from v1.10 onwards
    from airflow.utils import timezone
    now = timezone.utcnow
except ImportError:
    now = datetime.utcnow

# airflow-db-cleanup
DAG_ID = os.path.basename(__file__).replace(".pyc", "").replace(".py", "")
START_DATE = airflow.utils.dates.days_ago(1)
# How often to Run. @daily - Once a day at Midnight (UTC)
SCHEDULE_INTERVAL = "@daily"
# Who is listed as the owner of this DAG in the Airflow Web Server
DAG_OWNER_NAME = "operations"
# List of email address to send email alerts to if this job fails
ALERT_EMAIL_ADDRESSES = []
# Length to retain the log files if not already provided in the conf. If this
# is set to 30, the job will remove those files that arE 30 days old or older.

DEFAULT_MAX_DB_ENTRY_AGE_IN_DAYS = int(
    Variable.get("airflow_db_cleanup__max_db_entry_age_in_days", 30))
# Prints the database entries which will be getting deleted; set to False
# to avoid printing large lists and slowdown process
PRINT_DELETES = False
# Whether the job should delete the db entries or not. Included if you want to
# temporarily avoid deleting the db entries.
ENABLE_DELETE = True
# List of all the objects that will be deleted. Comment out the DB objects you
# want to skip.
DATABASE_OBJECTS = [{
    "airflow_db_model": BaseJob,
    "age_check_column": BaseJob.latest_heartbeat,
    "keep_last": False,
    "keep_last_filters": None,
    "keep_last_group_by": None
}, {
    "airflow_db_model": DagRun,
    "age_check_column": DagRun.execution_date,
    "keep_last": True,
    "keep_last_filters": [DagRun.external_trigger.is_(False)],
    "keep_last_group_by": DagRun.dag_id
}, {
    "airflow_db_model": TaskInstance,
    "age_check_column": TaskInstance.execution_date,
    "keep_last": False,
    "keep_last_filters": None,
    "keep_last_group_by": None
}, {
    "airflow_db_model": Log,
    "age_check_column": Log.dttm,
    "keep_last": False,
    "keep_last_filters": None,
    "keep_last_group_by": None
}, {
    "airflow_db_model": XCom,
    "age_check_column": XCom.execution_date,
    "keep_last": False,
    "keep_last_filters": None,
    "keep_last_group_by": None
}, {
    "airflow_db_model": SlaMiss,
    "age_check_column": SlaMiss.execution_date,
    "keep_last": False,
    "keep_last_filters": None,
    "keep_last_group_by": None
}, {
    "airflow_db_model": DagModel,
    "age_check_column": DagModel.last_scheduler_run,
    "keep_last": False,
    "keep_last_filters": None,
    "keep_last_group_by": None
}]

# Check for TaskReschedule model
try:
    from airflow.models import TaskReschedule
    DATABASE_OBJECTS.append({
        "airflow_db_model": TaskReschedule,
        "age_check_column": TaskReschedule.execution_date,
        "keep_last": False,
        "keep_last_filters": None,
        "keep_last_group_by": None
    })

except Exception as e:
    logging.error(e)

# Check for TaskFail model
try:
    from airflow.models import TaskFail
    DATABASE_OBJECTS.append({
        "airflow_db_model": TaskFail,
        "age_check_column": TaskFail.execution_date,
        "keep_last": False,
        "keep_last_filters": None,
        "keep_last_group_by": None
    })

except Exception as e:
    logging.error(e)

# Check for RenderedTaskInstanceFields model
try:
    from airflow.models import RenderedTaskInstanceFields
    DATABASE_OBJECTS.append({
        "airflow_db_model": RenderedTaskInstanceFields,
        "age_check_column": RenderedTaskInstanceFields.execution_date,
        "keep_last": False,
        "keep_last_filters": None,
        "keep_last_group_by": None
    })

except Exception as e:
    logging.error(e)

# Check for ImportError model
try:
    from airflow.models import ImportError
    DATABASE_OBJECTS.append({
        "airflow_db_model": ImportError,
        "age_check_column": ImportError.timestamp,
        "keep_last": False,
        "keep_last_filters": None,
        "keep_last_group_by": None
    })

except Exception as e:
    logging.error(e)

# Check for celery executor
airflow_executor = str(conf.get("core", "executor"))
logging.info("Airflow Executor: " + str(airflow_executor))
if (airflow_executor == "CeleryExecutor"):
    logging.info("Including Celery Modules")
    try:
        from celery.backends.database.models import Task, TaskSet
        DATABASE_OBJECTS.extend(({
            "airflow_db_model": Task,
            "age_check_column": Task.date_done,
            "keep_last": False,
            "keep_last_filters": None,
            "keep_last_group_by": None
        }, {
            "airflow_db_model": TaskSet,
            "age_check_column": TaskSet.date_done,
            "keep_last": False,
            "keep_last_filters": None,
            "keep_last_group_by": None
        }))

    except Exception as e:
        logging.error(e)

session = settings.Session()

default_args = {
    "owner": DAG_OWNER_NAME,
    "depends_on_past": False,
    "email": ALERT_EMAIL_ADDRESSES,
    "email_on_failure": True,
    "email_on_retry": False,
    "start_date": START_DATE,
    "retries": 1,
    "retry_delay": timedelta(minutes=1)
}

dag = DAG(
    DAG_ID,
    default_args=default_args,
    schedule_interval=SCHEDULE_INTERVAL,
    start_date=START_DATE)
if hasattr(dag, "doc_md"):
    dag.doc_md = __doc__
if hasattr(dag, "catchup"):
    dag.catchup = False

def print_configuration_function(**context):
    logging.info("Loading Configurations...")
    dag_run_conf = context.get("dag_run").conf
    logging.info("dag_run.conf: " + str(dag_run_conf))
    max_db_entry_age_in_days = None
    if dag_run_conf:
        max_db_entry_age_in_days = dag_run_conf.get(
            "maxDBEntryAgeInDays", None)
    logging.info("maxDBEntryAgeInDays from dag_run.conf: " + str(dag_run_conf))
    if (max_db_entry_age_in_days is None or max_db_entry_age_in_days < 1):
        logging.info(
            "maxDBEntryAgeInDays conf variable isn't included or Variable " +
            "value is less than 1. Using Default '" +
            str(DEFAULT_MAX_DB_ENTRY_AGE_IN_DAYS) + "'")
        max_db_entry_age_in_days = DEFAULT_MAX_DB_ENTRY_AGE_IN_DAYS
    max_date = now() + timedelta(-max_db_entry_age_in_days)
    logging.info("Finished Loading Configurations")
    logging.info("")

    logging.info("Configurations:")
    logging.info("max_db_entry_age_in_days: " + str(max_db_entry_age_in_days))
    logging.info("max_date:                 " + str(max_date))
    logging.info("enable_delete:            " + str(ENABLE_DELETE))
    logging.info("session:                  " + str(session))
    logging.info("")

    logging.info("Setting max_execution_date to XCom for Downstream Processes")
    context["ti"].xcom_push(key="max_date", value=max_date.isoformat())

print_configuration = PythonOperator(
    task_id="print_configuration",
    python_callable=print_configuration_function,
    provide_context=True,
    dag=dag)

def cleanup_function(**context):

    logging.info("Retrieving max_execution_date from XCom")
    max_date = context["ti"].xcom_pull(
        task_ids=print_configuration.task_id, key="max_date")
    max_date = dateutil.parser.parse(max_date)  # stored as iso8601 str in xcom

    airflow_db_model = context["params"].get("airflow_db_model")
    state = context["params"].get("state")
    age_check_column = context["params"].get("age_check_column")
    keep_last = context["params"].get("keep_last")
    keep_last_filters = context["params"].get("keep_last_filters")
    keep_last_group_by = context["params"].get("keep_last_group_by")

    logging.info("Configurations:")
    logging.info("max_date:                 " + str(max_date))
    logging.info("enable_delete:            " + str(ENABLE_DELETE))
    logging.info("session:                  " + str(session))
    logging.info("airflow_db_model:         " + str(airflow_db_model))
    logging.info("state:                    " + str(state))
    logging.info("age_check_column:         " + str(age_check_column))
    logging.info("keep_last:                " + str(keep_last))
    logging.info("keep_last_filters:        " + str(keep_last_filters))
    logging.info("keep_last_group_by:       " + str(keep_last_group_by))

    logging.info("")

    logging.info("Running Cleanup Process...")

    try:
        query = session.query(airflow_db_model).options(
            load_only(age_check_column))

        logging.info("INITIAL QUERY : " + str(query))

        if keep_last:

            subquery = session.query(func.max(DagRun.execution_date))
            # workaround for MySQL "table specified twice" issue
            # https://github.com/teamclairvoyant/airflow-maintenance-dags/issues/41
            if keep_last_filters is not None:
                for entry in keep_last_filters:
                    subquery = subquery.filter(entry)

                logging.info("SUB QUERY [keep_last_filters]: " + str(subquery))

            if keep_last_group_by is not None:
                subquery = subquery.group_by(keep_last_group_by)
                logging.info(
                    "SUB QUERY [keep_last_group_by]: " +
                    str(subquery))

            subquery = subquery.from_self()

            query = query.filter(
                and_(age_check_column.notin_(subquery)),
                and_(age_check_column <= max_date))

        else:
            query = query.filter(age_check_column <= max_date,)

        if PRINT_DELETES:
            entries_to_delete = query.all()

            logging.info("Query: " + str(query))
            logging.info("Process will be Deleting the following " +
                         str(airflow_db_model.__name__) + "(s):")
            for entry in entries_to_delete:
                date = str(entry.__dict__[str(age_check_column).split(".")[1]])
                logging.info("\tEntry: " + str(entry) + ", Date: " + date)

            logging.info("Process will be Deleting "
                         + str(len(entries_to_delete)) + " "
                         + str(airflow_db_model.__name__) + "(s)")
        else:
            logging.warn(
                "You've opted to skip printing the db entries to be deleted. "
                "Set PRINT_DELETES to True to show entries!!!")

        if ENABLE_DELETE:
            logging.info("Performing Delete...")
            # using bulk delete
            query.delete(synchronize_session=False)
            session.commit()
            logging.info("Finished Performing Delete")
        else:
            logging.warn("You've opted to skip deleting the db entries. "
                         "Set ENABLE_DELETE to True to delete entries!!!")

        logging.info("Finished Running Cleanup Process")

    except ProgrammingError as e:
        logging.error(e)
        logging.error(
            str(airflow_db_model) + " is not present in the metadata."
            "Skipping...")

for db_object in DATABASE_OBJECTS:

    cleanup_op = PythonOperator(
        task_id="cleanup_" + str(db_object["airflow_db_model"].__name__),
        python_callable=cleanup_function,
        params=db_object,
        provide_context=True,
        dag=dag)

    print_configuration.set_downstream(cleanup_op)

Sie können auch Einträge zu nicht mehr benötigten DAGs entfernen, wie im Abschnitt DAG löschen beschrieben.

Beschränkungen

  • Ein Downgrade auf eine frühere Version von Cloud Composer oder Airflow ist nicht möglich.
  • Upgrades können nur auf die neueste Cloud Composer-Version innerhalb der gleichen Hauptversion ausgeführt werden, z. B. von composer-1.12.4-airflow-1.10.10 auf composer-1.13.0-airflow-1.10.10. Ein Upgrade von composer-1.4.0-airflow-1.10.0 auf composer-2.0.0-airflow-1.10.0 ist nicht zulässig, da sich die Hauptversion von Cloud Composer von 1 zu 2 ändert.
  • Die Image-Version, auf die Sie upgraden, muss die aktuelle Python-Version Ihrer Umgebung unterstützen.
  • Upgrades können nicht ausgeführt werden, wenn die Airflow-Datenbank mehr als 16 GB Daten umfasst. Während des Upgrades wird eine Warnung angezeigt, wenn dies der Fall ist. Sie müssen dann eine Datenbankwartung machen, wie im Abschnitt zur Airflow-Datenbank-Wartung beschrieben.

Einstellungsnachrichten

Cloud Composer lehnt Warnungen ab, wenn das Umgebungs-Image das Enddatum der Unterstützung erreicht. Sie können diese Warnungen verwenden, um Ihre Umgebungen während des gesamten Supportzeitraums immer auf dem neuesten Stand zu halten.

Nachricht zur Einstellung

Cloud Composer verfolgt die Cloud Composer-Image-Version, auf der Ihre Umgebung basiert. Wenn das Image das Enddatum der Unterstützung erreicht, wird in der Liste der Umgebungen und auf der Seite Umgebungsdetails eine Warnung angezeigt.

So prüfen Sie, ob Ihr Umgebungs-Image auf dem neuesten Stand ist:

  1. Rufen Sie in der Google Cloud Console die Seite Umgebungen auf:

    Zur Seite "Umgebungen"

  2. Klicken Sie auf den Namen der Umgebung, um deren Details aufzurufen.

  3. Suchen Sie unter Umgebungskonfiguration das Feld Image-Version.

  4. Im Feld Image-Version wird eine der folgenden Meldungen angezeigt:

    • Neueste verfügbare Version: Das Umgebungsimage wird vollständig unterstützt.

    • Neue Version verfügbar: Das Umgebungs-Image wird vollständig unterstützt und kann auf eine neuere Version aktualisiert werden.

    • Unterstützung für diese Image-Version endet in... Das Umgebungsimage erreicht das Ende des vollständigen Supportzeitraums.

    • Diese Version wird ab dem...nicht unterstützt Ihre Umgebung hat den gesamten Supportzeitraum überschritten.

Verfügbare Upgrades aufrufen

So lassen Sie eine Liste der Cloud Composer-Versionen anzeigen, auf die Sie ein Upgrade durchführen können:

Console

  1. Rufen Sie in der Google Cloud Console die Seite Umgebungen auf:

    Seite "Umgebungen" öffnen

  2. Klicken Sie unter Name auf den Namen der Umgebung.

  3. Klicken Sie im Tab Umgebung konfigurieren auf Upgrade für Image-Version ausführen.

  4. Klicken Sie auf das Drop-down-Menü Image-Version für Cloud Composer, um die verfügbaren Versionen aufzurufen.

gcloud

gcloud beta composer environments list-upgrades ENVIRONMENT_NAME \
    --location LOCATION 

Dabei gilt:

  • ENVIRONMENT_NAME ist der Name der Umgebung.
  • LOCATION ist die Compute Engine-Region, in der sich die Umgebung befindet.

Beispiel:

gcloud beta composer environments list-upgrades test-environment \
    --location us-central1
┌─────────────────────────────────────────────────────────────────────────────┐
│                              AVAILABLE UPGRADES                             │
├──────────────────────────────┬──────────────────┬───────────────────────────┤
│        IMAGE VERSION         │ COMPOSER DEFAULT │ SUPPORTED PYTHON VERSIONS │
├──────────────────────────────┼──────────────────┼───────────────────────────┤
│ composer-1.4.0-airflow-1.9.0 │ True             │ 2,3                       │
└──────────────────────────────┴──────────────────┴───────────────────────────┘

API

Zur Darstellung der verfügbaren Versionen mit der Cloud Composer REST API erstellen Sie eine imageVersions.list-API-Anfrage und geben das Projekt und den Standort im Format projects/{projectId}/locations/{locationId} an.

Beispiel:

GET https://composer.googleapis.com/v1/projects/test-project-id/locations/us-central1/imageVersions

{
  "imageVersions": [
    {
      "imageVersionId": "composer-1.4.2-airflow-1.10.0",
      "supportedPythonVersions": [
        "2",
        "3"
      ]
    },
    {
      "imageVersionId": "composer-1.4.2-airflow-1.9.0",
      "isDefault": true,
      "supportedPythonVersions": [
        "2",
        "3"
      ]
    }
  ]
} 

Upgrade der Cloud Composer-Version durchführen

So führen Sie ein Upgrade der Cloud Composer-Version durch, die in Ihrer Umgebung ausgeführt wird:

Console

  1. Rufen Sie in der Google Cloud Console die Seite Umgebungen auf:

    Seite "Umgebungen" öffnen

  2. Klicken Sie unter Name auf den Namen der Umgebung, die Sie ändern möchten.

  3. Klicken Sie im Tab Umgebung konfigurieren auf Upgrade für Image-Version ausführen.

  4. Klicken Sie auf das Drop-down-Menü Image-Version für Cloud Composer und wählen Sie eine Version aus.

  5. Klicken Sie auf Senden.

gcloud

gcloud beta composer environments update ENVIRONMENT_NAME \
    --location LOCATION --image-version VERSION

Dabei gilt:

  • ENVIRONMENT_NAME ist der Name der Umgebung.
  • LOCATION ist die Compute Engine-Region, in der sich die Umgebung befindet.
  • VERSION ist die Cloud Composer-Version oder die Airflow-Version für die Umgebung im Format composer-a.b.c-airflow-x.y.z oder composer-a.b.c-airflow-x.y. Wenn Sie den Airflow-Patch nicht angeben, wird die höchste verfügbare Patchversion für die angegebene Haupt- und Nebenversion verwendet.

Beispiel:

gcloud beta composer environments update test-environment \
    --location us-central1 --image-version composer-latest-airflow-1.10.1 

API

Zum Ausführen eines Upgrades mit der Cloud Composer REST API erstellen Sie eine environments.patch-API-Anfrage. Geben Sie die Version im Format composer-a.b.c-airflow-x.y.z an.

Beispiel:

PATCH https://composer.googleapis.com/v1beta1/projects/test-project/locations/us-central1/environments/test-environment?updateMask=config.software_config.image_version

Der Anfragetext enthält imageVersion:

{
  "config": {
    "softwareConfig": {
      "imageVersion": "composer-1.6.0-airflow-1.10.1"
    }
  }
}

Upgrade der Airflow-Version ausführen

Wenn in Ihrer Umgebung bereits die aktuelle Cloud Composer-Version ausgeführt wird, können Sie mit dem Cloud SDK nur die Airflow-Version aktualisieren, z. B. ein Upgrade von composer-1.6.1-airflow-1.9.0 auf composer-1.6.1-airflow-1.10.0.

gcloud beta composer environments update ENVIRONMENT_NAME \
--location LOCATION --airflow-version VERSION

Dabei gilt:

  • ENVIRONMENT_NAME ist der Name der Umgebung.
  • LOCATION ist die Compute Engine-Region, in der sich die Umgebung befindet.
  • VERSION ist die Airflow-Version für Ihre Umgebung im Format x.y.z oder x.y.

Beispiel:

gcloud beta composer environments update test-environment \
--location us-central1 --airflow-version=1.10.1