apache-airflow-providers-google 8.12.0rc1__py3-none-any.whl → 9.0.0rc2__py3-none-any.whl

airflow/providers/google/ads/hooks/ads.py

@@ -26,21 +26,21 @@ from google.auth.exceptions import GoogleAuthError
 from airflow import AirflowException
 from airflow.compat.functools import cached_property
 from airflow.hooks.base import BaseHook
-from airflow.providers.google.ads._vendor.googleads.client import GoogleAdsClient
-from airflow.providers.google.ads._vendor.googleads.errors import GoogleAdsException
-from airflow.providers.google.ads._vendor.googleads.v12.services.services.customer_service import (
+from airflow.providers.google.common.hooks.base_google import get_field
+from airflow.providers.google_vendor.googleads.client import GoogleAdsClient
+from airflow.providers.google_vendor.googleads.errors import GoogleAdsException
+from airflow.providers.google_vendor.googleads.v12.services.services.customer_service import (
     CustomerServiceClient,
 )
-from airflow.providers.google.ads._vendor.googleads.v12.services.services.google_ads_service import (
+from airflow.providers.google_vendor.googleads.v12.services.services.google_ads_service import (
     GoogleAdsServiceClient,
 )
-from airflow.providers.google.ads._vendor.googleads.v12.services.services.google_ads_service.pagers import (
+from airflow.providers.google_vendor.googleads.v12.services.services.google_ads_service.pagers import (
     SearchPager,
 )
-from airflow.providers.google.ads._vendor.googleads.v12.services.types.google_ads_service import (
+from airflow.providers.google_vendor.googleads.v12.services.types.google_ads_service import (
     GoogleAdsRow,
 )
-from airflow.providers.google.common.hooks.base_google import get_field
 
 
 class GoogleAdsHook(BaseHook):

airflow/providers/google/cloud/hooks/bigquery.py

@@ -34,6 +34,7 @@ from typing import Any, Iterable, Mapping, NoReturn, Sequence, Union, cast
 
 from aiohttp import ClientSession as ClientSession
 from gcloud.aio.bigquery import Job, Table as Table_async
+from google.api_core.page_iterator import HTTPIterator
 from google.api_core.retry import Retry
 from google.cloud.bigquery import (
     DEFAULT_RETRY,
@@ -46,7 +47,7 @@ from google.cloud.bigquery import (
     SchemaField,
 )
 from google.cloud.bigquery.dataset import AccessEntry, Dataset, DatasetListItem, DatasetReference
-from google.cloud.bigquery.table import EncryptionConfiguration, Row, Table, TableReference
+from google.cloud.bigquery.table import EncryptionConfiguration, Row, RowIterator, Table, TableReference
 from google.cloud.exceptions import NotFound
 from googleapiclient.discovery import Resource, build
 from pandas import DataFrame
@@ -1006,7 +1007,8 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         max_results: int | None = None,
         page_token: str | None = None,
         retry: Retry = DEFAULT_RETRY,
-    ) -> list[DatasetListItem]:
+        return_iterator: bool = False,
+    ) -> list[DatasetListItem] | HTTPIterator:
         """
         Method returns full list of BigQuery datasets in the current project
 
@@ -1026,8 +1028,10 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
             ``next_page_token`` of the :class:`~google.api_core.page_iterator.HTTPIterator`.
         :param page_token: str
         :param retry: How to retry the RPC.
+        :param return_iterator: Instead of returning a list[Row], returns a HTTPIterator
+            which can be used to obtain the next_page_token property.
         """
-        datasets = self.get_client(project_id=project_id).list_datasets(
+        iterator = self.get_client(project_id=project_id).list_datasets(
             project=project_id,
             include_all=include_all,
             filter=filter_,
@@ -1035,8 +1039,13 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
             page_token=page_token,
             retry=retry,
         )
-        datasets_list = list(datasets)
 
+        # If iterator is requested, we cannot perform a list() on it to log the number
+        # of datasets because we will have started iteration
+        if return_iterator:
+            return iterator
+
+        datasets_list = list(iterator)
         self.log.info("Datasets List: %s", len(datasets_list))
         return datasets_list
 
@@ -1232,7 +1241,9 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         start_index: int | None = None,
         project_id: str | None = None,
         location: str | None = None,
-    ) -> list[Row]:
+        retry: Retry = DEFAULT_RETRY,
+        return_iterator: bool = False,
+    ) -> list[Row] | RowIterator:
         """
         List the rows of the table.
         See https://cloud.google.com/bigquery/docs/reference/rest/v2/tabledata/list
@@ -1247,6 +1258,9 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
         :param start_index: zero based index of the starting row to read.
         :param project_id: Project ID for the project which the client acts on behalf of.
         :param location: Default location for job.
+        :param retry: How to retry the RPC.
+        :param return_iterator: Instead of returning a list[Row], returns a RowIterator
+            which can be used to obtain the next_page_token property.
         :return: list of rows
         """
         location = location or self.location
@@ -1265,14 +1279,17 @@ class BigQueryHook(GoogleBaseHook, DbApiHook):
             table_id=table_id,
         )
 
-        result = self.get_client(project_id=project_id, location=location).list_rows(
+        iterator = self.get_client(project_id=project_id, location=location).list_rows(
             table=Table.from_api_repr(table),
             selected_fields=selected_fields,
             max_results=max_results,
             page_token=page_token,
             start_index=start_index,
+            retry=retry,
         )
-        return list(result)
+        if return_iterator:
+            return iterator
+        return list(iterator)
 
     @GoogleBaseHook.fallback_to_default_project_id
     def get_schema(self, dataset_id: str, table_id: str, project_id: str | None = None) -> dict:
@@ -2455,7 +2472,7 @@ class BigQueryBaseCursor(LoggingMixin):
         )
         return self.hook.get_dataset_tables_list(*args, **kwargs)
 
-    def get_datasets_list(self, *args, **kwargs) -> list:
+    def get_datasets_list(self, *args, **kwargs) -> list | HTTPIterator:
         """
         This method is deprecated.
         Please use `airflow.providers.google.cloud.hooks.bigquery.BigQueryHook.get_datasets_list`

airflow/providers/google/cloud/hooks/cloud_build.py

@@ -645,7 +645,9 @@ class CloudBuildAsyncHook(GoogleBaseHook):
         client_options = None
         if location != "global":
             client_options = ClientOptions(api_endpoint=f"{location}-cloudbuild.googleapis.com:443")
-        client = CloudBuildAsyncClient(client_options=client_options)
+        client = CloudBuildAsyncClient(
+            credentials=self.get_credentials(), client_info=CLIENT_INFO, client_options=client_options
+        )
 
         request = GetBuildRequest(
             project_id=project_id,

airflow/providers/google/cloud/hooks/kubernetes_engine.py

@@ -25,22 +25,33 @@ This module contains a Google Kubernetes Engine Hook.
 """
 from __future__ import annotations
 
+import contextlib
 import json
 import time
 import warnings
 from typing import Sequence
 
+import google.auth.credentials
+from gcloud.aio.auth import Token
 from google.api_core.exceptions import NotFound
 from google.api_core.gapic_v1.method import DEFAULT, _MethodDefault
 from google.api_core.retry import Retry
+from google.auth.transport import requests as google_requests
 
 # not sure why but mypy complains on missing `container_v1` but it is clearly there and is importable
 from google.cloud import container_v1, exceptions  # type: ignore[attr-defined]
 from google.cloud.container_v1 import ClusterManagerAsyncClient, ClusterManagerClient
 from google.cloud.container_v1.types import Cluster, Operation
+from kubernetes import client
+from kubernetes_asyncio import client as async_client
+from kubernetes_asyncio.client.models import V1Pod
+from kubernetes_asyncio.config.kube_config import FileOrData
+from urllib3.exceptions import HTTPError
 
 from airflow import version
+from airflow.compat.functools import cached_property
 from airflow.exceptions import AirflowException
+from airflow.kubernetes.pod_generator_deprecated import PodDefaults
 from airflow.providers.google.common.consts import CLIENT_INFO
 from airflow.providers.google.common.hooks.base_google import (
     PROVIDE_PROJECT_ID,
@@ -53,7 +64,7 @@ OPERATIONAL_POLL_INTERVAL = 15
 
 class GKEHook(GoogleBaseHook):
     """
-    Hook for Google Kubernetes Engine APIs.
+    Hook for managing Google Kubernetes Engine cluster APIs.
 
     All the methods in the hook where project_id is used must be called with
     keyword arguments rather than positional.
@@ -66,10 +77,6 @@ class GKEHook(GoogleBaseHook):
         location: str | None = None,
         impersonation_chain: str | Sequence[str] | None = None,
     ) -> None:
-        if delegate_to:
-            warnings.warn(
-                "'delegate_to' parameter is deprecated, please use 'impersonation_chain'", DeprecationWarning
-            )
         super().__init__(
             gcp_conn_id=gcp_conn_id,
             delegate_to=delegate_to,
@@ -288,7 +295,7 @@ class GKEHook(GoogleBaseHook):
         )
 
 
-class AsyncGKEHook(GoogleBaseAsyncHook):
+class GKEAsyncHook(GoogleBaseAsyncHook):
     """Hook implemented with usage of asynchronous client of GKE."""
 
     sync_hook_class = GKEHook
@@ -336,3 +343,195 @@ class AsyncGKEHook(GoogleBaseAsyncHook):
         return await client.get_operation(
             name=operation_path,
         )
+
+
+class GKEPodHook(GoogleBaseHook):
+    """Hook for managing Google Kubernetes Engine pod APIs."""
+
+    def __init__(
+        self,
+        cluster_url: str,
+        ssl_ca_cert: str,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self._cluster_url = cluster_url
+        self._ssl_ca_cert = ssl_ca_cert
+
+    @cached_property
+    def api_client(self) -> client.ApiClient:
+        return self.get_conn()
+
+    @cached_property
+    def core_v1_client(self) -> client.CoreV1Api:
+        return client.CoreV1Api(self.api_client)
+
+    @property
+    def is_in_cluster(self) -> bool:
+        return False
+
+    @staticmethod
+    def get_xcom_sidecar_container_image():
+        """Returns the xcom sidecar image that defined in the connection"""
+        return PodDefaults.SIDECAR_CONTAINER.image
+
+    def get_conn(self) -> client.ApiClient:
+        configuration = self._get_config()
+        return client.ApiClient(configuration)
+
+    def _get_config(self) -> client.configuration.Configuration:
+        configuration = client.Configuration(
+            host=self._cluster_url,
+            api_key_prefix={"authorization": "Bearer"},
+            api_key={"authorization": self._get_token(self.get_credentials())},
+        )
+        configuration.ssl_ca_cert = FileOrData(
+            {
+                "certificate-authority-data": self._ssl_ca_cert,
+            },
+            file_key_name="certificate-authority",
+        ).as_file()
+        return configuration
+
+    @staticmethod
+    def _get_token(creds: google.auth.credentials.Credentials) -> str:
+        if creds.token is None or creds.expired:
+            auth_req = google_requests.Request()
+            creds.refresh(auth_req)
+        return creds.token
+
+    def get_pod(self, name: str, namespace: str) -> V1Pod:
+        """
+        Gets pod's object.
+
+        :param name: Name of the pod.
+        :param namespace: Name of the pod's namespace.
+        """
+        return self.core_v1_client.read_namespaced_pod(
+            name=name,
+            namespace=namespace,
+        )
+
+
+class GKEPodAsyncHook(GoogleBaseAsyncHook):
+    """
+    Hook for managing Google Kubernetes Engine pods APIs in asynchronous way.
+
+    :param cluster_url: The URL pointed to the cluster.
+    :param ssl_ca_cert: SSL certificate that is used for authentication to the pod.
+    """
+
+    sync_hook_class = GKEPodHook
+    scopes = ["https://www.googleapis.com/auth/cloud-platform"]
+
+    def __init__(
+        self,
+        cluster_url: str,
+        ssl_ca_cert: str,
+        **kwargs,
+    ):
+
+        self._cluster_url = cluster_url
+        self._ssl_ca_cert = ssl_ca_cert
+
+        kwargs.update(
+            cluster_url=cluster_url,
+            ssl_ca_cert=ssl_ca_cert,
+        )
+        super().__init__(**kwargs)
+
+    @contextlib.asynccontextmanager
+    async def get_conn(self, token: Token) -> async_client.ApiClient:  # type: ignore[override]
+        kube_client = None
+        try:
+            kube_client = await self._load_config(token)
+            yield kube_client
+        finally:
+            if kube_client is not None:
+                await kube_client.close()
+
+    async def _load_config(self, token: Token) -> async_client.ApiClient:
+        configuration = self._get_config()
+        access_token = await token.get()
+        return async_client.ApiClient(
+            configuration,
+            header_name="Authorization",
+            header_value=f"Bearer {access_token}",
+        )
+
+    def _get_config(self) -> async_client.configuration.Configuration:
+        configuration = async_client.Configuration(
+            host=self._cluster_url,
+            ssl_ca_cert=FileOrData(
+                {
+                    "certificate-authority-data": self._ssl_ca_cert,
+                },
+                file_key_name="certificate-authority",
+            ).as_file(),
+        )
+        return configuration
+
+    async def get_pod(self, name: str, namespace: str) -> V1Pod:
+        """
+        Gets pod's object.
+
+        :param name: Name of the pod.
+        :param namespace: Name of the pod's namespace.
+        """
+        async with Token(scopes=self.scopes) as token:
+            async with self.get_conn(token) as connection:
+                v1_api = async_client.CoreV1Api(connection)
+                pod: V1Pod = await v1_api.read_namespaced_pod(
+                    name=name,
+                    namespace=namespace,
+                )
+            return pod
+
+    async def delete_pod(self, name: str, namespace: str):
+        """
+        Deletes pod's object.
+
+        :param name: Name of the pod.
+        :param namespace: Name of the pod's namespace.
+        """
+        async with Token(scopes=self.scopes) as token:
+            async with self.get_conn(token) as connection:
+                try:
+                    v1_api = async_client.CoreV1Api(connection)
+                    await v1_api.delete_namespaced_pod(
+                        name=name,
+                        namespace=namespace,
+                        body=client.V1DeleteOptions(),
+                    )
+                except async_client.ApiException as e:
+                    # If the pod is already deleted
+                    if e.status != 404:
+                        raise
+
+    async def read_logs(self, name: str, namespace: str):
+        """
+        Reads logs inside the pod while starting containers inside. All the logs will be outputted with its
+        timestamp to track the logs after the execution of the pod is completed. The method is used for async
+        output of the logs only in the pod failed it execution or the task was cancelled by the user.
+
+        :param name: Name of the pod.
+        :param namespace: Name of the pod's namespace.
+        """
+        async with Token(scopes=self.scopes) as token:
+            async with self.get_conn(token) as connection:
+                try:
+                    v1_api = async_client.CoreV1Api(connection)
+                    logs = await v1_api.read_namespaced_pod_log(
+                        name=name,
+                        namespace=namespace,
+                        follow=False,
+                        timestamps=True,
+                    )
+                    logs = logs.splitlines()
+                    for line in logs:
+                        self.log.info("Container logs from %s", line)
+                    return logs
+                except HTTPError:
+                    self.log.exception("There was an error reading the kubernetes API.")
+                    raise

airflow/providers/google/cloud/operators/kubernetes_engine.py

@@ -18,15 +18,14 @@
 """This module contains Google Kubernetes Engine operators."""
 from __future__ import annotations
 
-import os
-import tempfile
 import warnings
-from contextlib import contextmanager
-from typing import TYPE_CHECKING, Generator, Sequence
+from typing import TYPE_CHECKING, Sequence
 
 from google.api_core.exceptions import AlreadyExists
 from google.cloud.container_v1.types import Cluster
+from kubernetes.client.models import V1Pod
 
+from airflow.compat.functools import cached_property
 from airflow.exceptions import AirflowException
 
 try:
@@ -34,15 +33,14 @@ try:
 except ImportError:
     # preserve backward compatibility for older versions of cncf.kubernetes provider
     from airflow.providers.cncf.kubernetes.operators.kubernetes_pod import KubernetesPodOperator
-from airflow.providers.google.cloud.hooks.kubernetes_engine import GKEHook
+from airflow.providers.google.cloud.hooks.kubernetes_engine import GKEHook, GKEPodHook
 from airflow.providers.google.cloud.links.kubernetes_engine import (
     KubernetesEngineClusterLink,
     KubernetesEnginePodLink,
 )
 from airflow.providers.google.cloud.operators.cloud_base import GoogleCloudBaseOperator
-from airflow.providers.google.cloud.triggers.kubernetes_engine import GKEOperationTrigger
-from airflow.providers.google.common.hooks.base_google import GoogleBaseHook
-from airflow.utils.process_utils import execute_in_subprocess, patch_environ
+from airflow.providers.google.cloud.triggers.kubernetes_engine import GKEOperationTrigger, GKEStartPodTrigger
+from airflow.utils.timezone import utcnow
 
 if TYPE_CHECKING:
     from airflow.utils.context import Context
@@ -233,6 +231,8 @@ class GKECreateClusterOperator(GoogleCloudBaseOperator):
         If set as a sequence, the identities from the list must grant
         Service Account Token Creator IAM role to the directly preceding identity, with first
         account from the list granting this role to the originating account (templated).
+    :param deferrable: Run operator in the deferrable mode.
+    :param poll_interval: Interval size which defines how often operation status is checked.
     """
 
     template_fields: Sequence[str] = (
@@ -363,7 +363,7 @@ class GKECreateClusterOperator(GoogleCloudBaseOperator):
 class GKEStartPodOperator(KubernetesPodOperator):
     """
     Executes a task in a Kubernetes pod in the specified Google Kubernetes
-    Engine cluster
+    Engine cluster.
 
     This Operator assumes that the system has gcloud installed and has configured a
     connection id with a service account.
@@ -386,7 +386,7 @@ class GKEStartPodOperator(KubernetesPodOperator):
         should be spawned in
     :param use_internal_ip: Use the internal IP address as the endpoint.
     :param project_id: The Google Developers Console project id
-    :param gcp_conn_id: The google cloud connection id to use. This allows for
+    :param gcp_conn_id: The Google cloud connection id to use. This allows for
         users to specify a service account.
     :param impersonation_chain: Optional service account to impersonate using short-term
         credentials, or list of accounts required to get the access_token
@@ -399,8 +399,9 @@ class GKEStartPodOperator(KubernetesPodOperator):
     :param regional: The location param is region name.
     :param is_delete_operator_pod: What to do when the pod reaches its final
         state, or the execution is interrupted. If True, delete the
-        pod; if False, leave the pod.  Current default is False, but this will be
+        pod; if False, leave the pod. Current default is False, but this will be
         changed in the next major release of this provider.
+    :param deferrable: Run operator in the deferrable mode.
     """
 
     template_fields: Sequence[str] = tuple(
@@ -413,11 +414,11 @@ class GKEStartPodOperator(KubernetesPodOperator):
         *,
         location: str,
         cluster_name: str,
-        use_internal_ip: bool = False,
+        use_internal_ip: bool | None = None,
         project_id: str | None = None,
         gcp_conn_id: str = "google_cloud_default",
         impersonation_chain: str | Sequence[str] | None = None,
-        regional: bool = False,
+        regional: bool | None = None,
         is_delete_operator_pod: bool | None = None,
         **kwargs,
     ) -> None:
@@ -432,14 +433,34 @@ class GKEStartPodOperator(KubernetesPodOperator):
             )
             is_delete_operator_pod = False
 
+        if use_internal_ip is not None:
+            warnings.warn(
+                f"You have set parameter use_internal_ip in class {self.__class__.__name__}. "
+                "In current implementation of the operator the parameter is not used and will "
+                "be deleted in future.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        if regional is not None:
+            warnings.warn(
+                f"You have set parameter regional in class {self.__class__.__name__}. "
+                "In current implementation of the operator the parameter is not used and will "
+                "be deleted in future.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         super().__init__(is_delete_operator_pod=is_delete_operator_pod, **kwargs)
         self.project_id = project_id
         self.location = location
         self.cluster_name = cluster_name
         self.gcp_conn_id = gcp_conn_id
-        self.use_internal_ip = use_internal_ip
         self.impersonation_chain = impersonation_chain
-        self.regional = regional
+
+        self.pod: V1Pod | None = None
+        self._ssl_ca_cert: str | None = None
+        self._cluster_url: str | None = None
 
         if self.gcp_conn_id is None:
             raise AirflowException(
@@ -453,88 +474,77 @@ class GKEStartPodOperator(KubernetesPodOperator):
             raise AirflowException("config_file is not an allowed parameter for the GKEStartPodOperator.")
 
     @staticmethod
-    @contextmanager
-    def get_gke_config_file(
-        gcp_conn_id,
-        project_id: str | None,
-        cluster_name: str,
-        impersonation_chain: str | Sequence[str] | None,
-        regional: bool,
-        location: str,
-        use_internal_ip: bool,
-    ) -> Generator[str, None, None]:
+    def get_gke_config_file():
+        warnings.warn(
+            "The `get_gke_config_file` method is deprecated, "
+            "please use `fetch_cluster_info` instead to get the cluster info for connecting to it.",
+            DeprecationWarning,
+            stacklevel=1,
+        )
 
-        hook = GoogleBaseHook(gcp_conn_id=gcp_conn_id)
-        project_id = project_id or hook.project_id
+    @cached_property
+    def cluster_hook(self) -> GKEHook:
+        return GKEHook(
+            gcp_conn_id=self.gcp_conn_id,
+            location=self.location,
+            impersonation_chain=self.impersonation_chain,
+        )
 
-        if not project_id:
-            raise AirflowException(
-                "The project id must be passed either as "
-                "keyword project_id parameter or as project_id extra "
-                "in Google Cloud connection definition. Both are not set!"
+    @cached_property
+    def hook(self) -> GKEPodHook:  # type: ignore[override]
+        if self._cluster_url is None or self._ssl_ca_cert is None:
+            raise AttributeError(
+                "Cluster url and ssl_ca_cert should be defined before using self.hook method. "
+                "Try to use self.get_kube_creds method",
             )
 
-        # Write config to a temp file and set the environment variable to point to it.
-        # This is to avoid race conditions of reading/writing a single file
-        with tempfile.NamedTemporaryFile() as conf_file, patch_environ(
-            {KUBE_CONFIG_ENV_VAR: conf_file.name}
-        ), hook.provide_authorized_gcloud():
-            # Attempt to get/update credentials
-            # We call gcloud directly instead of using google-cloud-python api
-            # because there is no way to write kubernetes config to a file, which is
-            # required by KubernetesPodOperator.
-            # The gcloud command looks at the env variable `KUBECONFIG` for where to save
-            # the kubernetes config file.
-            cmd = [
-                "gcloud",
-                "container",
-                "clusters",
-                "get-credentials",
-                cluster_name,
-                "--project",
-                project_id,
-            ]
-            if impersonation_chain:
-                if isinstance(impersonation_chain, str):
-                    impersonation_account = impersonation_chain
-                elif len(impersonation_chain) == 1:
-                    impersonation_account = impersonation_chain[0]
-                else:
-                    raise AirflowException(
-                        "Chained list of accounts is not supported, please specify only one service account"
-                    )
-
-                cmd.extend(
-                    [
-                        "--impersonate-service-account",
-                        impersonation_account,
-                    ]
-                )
-            if regional:
-                cmd.append("--region")
-            else:
-                cmd.append("--zone")
-            cmd.append(location)
-            if use_internal_ip:
-                cmd.append("--internal-ip")
-            execute_in_subprocess(cmd)
-
-            # Tell `KubernetesPodOperator` where the config file is located
-            yield os.environ[KUBE_CONFIG_ENV_VAR]
+        hook = GKEPodHook(
+            cluster_url=self._cluster_url,
+            ssl_ca_cert=self._ssl_ca_cert,
+        )
+        return hook
 
-    def execute(self, context: Context) -> str | None:
+    def execute(self, context: Context):
+        """Executes process of creating pod and executing provided command inside it."""
+        self.fetch_cluster_info()
+        return super().execute(context)
 
-        with GKEStartPodOperator.get_gke_config_file(
-            gcp_conn_id=self.gcp_conn_id,
+    def fetch_cluster_info(self) -> tuple[str, str | None]:
+        """Fetches cluster info for connecting to it."""
+        cluster = self.cluster_hook.get_cluster(
+            name=self.cluster_name,
             project_id=self.project_id,
-            cluster_name=self.cluster_name,
-            impersonation_chain=self.impersonation_chain,
-            regional=self.regional,
-            location=self.location,
-            use_internal_ip=self.use_internal_ip,
-        ) as config_file:
-            self.config_file = config_file
-            result = super().execute(context)
-            if not self.is_delete_operator_pod:
-                KubernetesEnginePodLink.persist(context=context, task_instance=self)
-            return result
+        )
+
+        self._cluster_url = f"https://{cluster.endpoint}"
+        self._ssl_ca_cert = cluster.master_auth.cluster_ca_certificate
+        return self._cluster_url, self._ssl_ca_cert
+
+    def invoke_defer_method(self):
+        """Method to easily redefine triggers which are being used in child classes."""
+        trigger_start_time = utcnow()
+        self.defer(
+            trigger=GKEStartPodTrigger(
+                pod_name=self.pod.metadata.name,
+                pod_namespace=self.pod.metadata.namespace,
+                trigger_start_time=trigger_start_time,
+                cluster_url=self._cluster_url,
+                ssl_ca_cert=self._ssl_ca_cert,
+                get_logs=self.get_logs,
+                startup_timeout=self.startup_timeout_seconds,
+                cluster_context=self.cluster_context,
+                poll_interval=self.poll_interval,
+                in_cluster=self.in_cluster,
+                should_delete_pod=self.is_delete_operator_pod,
+                base_container_name=self.base_container_name,
+            ),
+            method_name="execute_complete",
+            kwargs={"cluster_url": self._cluster_url, "ssl_ca_cert": self._ssl_ca_cert},
+        )
+
+    def execute_complete(self, context: Context, event: dict, **kwargs):
+        # It is required for hook to be initialized
+        self._cluster_url = kwargs["cluster_url"]
+        self._ssl_ca_cert = kwargs["ssl_ca_cert"]
+
+        return super().execute_complete(context, event, **kwargs)