Deployment Manager-Konfigurationen mit DM-Konvertierung konvertieren

Auf dieser Seite wird beschrieben, wie Sie mit DM Convert Ihre Deployment Manager-Konfigurationen in Kubernetes Resource Model (KRM) oder Terraform konvertieren.

Umgebung einrichten

Umgebungsvariablen einrichten

Speichern Sie die folgenden Umgebungsvariablen, die in diesem Leitfaden verwendet werden:

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
 --format="value(projectNumber)")
export DM_CONVERT_IMAGE="us-central1-docker.pkg.dev/\
dm-convert-host/deployment-manager/dm-convert:public-preview"

# Enable the Cloud Build API
gcloud services enable cloudbuild.googleapis.com

# Grant Cloud Build service account permission to manage Google Cloud Storage
# bucket and DM deployments
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
--member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \
--role=roles/storage.admin

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
--member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \
--role=roles/deploymentmanager.editor

Tools einrichten

Sie benötigen Zugriff auf die folgenden Tools:

  • gcloud

  • gsutil

  • docker

  • kubectl

Wenn Sie Cloud Shell zum Ausführen von DM Convert verwenden, haben Sie bereits Zugriff darauf.

In Cloud Shell öffnen

Konfigurationen konvertieren

Im Allgemeinen migrieren Sie Ihre Deployment Manager-Konfiguration so zu Terraform oder KRM:

  1. Deployment des Deployments für die Konvertierung vorbereiten

  2. Konfiguration in das HCL-Format (HashiCorp-Konfigurationssprache, für Terraform) oder das KRM-Format (Kubernetes Resource Model) konvertieren

  3. Terraform oder Config Connector verwenden, um die konvertierte Konfiguration anzuwenden

  4. Das vorhandene Deployment von Deployment Manager verwerfen

Vorhandenes Deployment vorbereiten

DM Convert wird für die Konfigurationsdateien und Vorlagen in Deployment Manager verwendet. Zur Bereitstellung dieser Dateien und Vorlagen für DM Convert verwenden Sie einen Cloud Storage-Bucket.

Führen Sie die folgenden Befehle aus, um einen Cloud Storage-Bucket zum Speichern der Deployment Manager-Konfiguration unter $BUCKET_URI zu erstellen:

export BUCKET_NAME=$PROJECT_ID-dm-config
export BUCKET_URI=gs://$BUCKET_NAME
gsutil mb $BUCKET_URI

# This is where we will store DM configuration to be converted
export DM_CONFIG_URI=$BUCKET_URI/dm

Sie können eine Konfigurationsdatei direkt dem Cloud Storage-Bucket hinzufügen oder eine Konfiguration aus einer Live-Bereitstellung übernehmen.

Konfigurationsdatei konvertieren

Sie können die Konvertierung mit der folgenden Beispielkonfiguration ausprobieren. Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-Projekt-ID und speichern Sie den folgenden Inhalt in einer Datei mit dem Namen deployment.yaml:

resources:
- name: bigquerydataset
  type: bigquery.v2.dataset
  properties:
    datasetReference:
      datasetId: bigquerydataset
      projectId: PROJECT_ID
    defaultTableExpirationMs: 36000000
    location: us-west1
- type: bigquery.v2.table
  name: bigquerytable
  properties:
    datasetId: bigquerydataset
    labels:
      data-source: external
      schema-type: auto-junk
    tableReference:
      projectId: PROJECT_ID
      tableId: bigquerytable
  metadata:
    dependsOn:
    - bigquerydataset

Nachdem Sie die Datei gespeichert haben, kopieren Sie sie in den zuvor erstellten Cloud Storage-Bucket:

gsutil cp ./deployment.yaml $DM_CONFIG_URI/deployment.yaml

Weisen Sie Ihrem Cloud Build-Dienstkonto die IAM-Rolle (Identity and Access Management, roles/bigquery.dataEditor) zu:

gcloud projects add-iam-policy-binding $PROJECT_ID \
--member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
--role=roles/bigquery.dataEditor

Konfiguration aus einer Live-Bereitstellung übernehmen

Wenn Sie die Konfiguration einer Live-Bereitstellung abrufen und konvertieren möchten, können Sie die erweiterte Konfiguration abrufen und auf dem Laufwerk speichern. Führen Sie dazu die folgenden Befehle aus. Ersetzen Sie dabei DEPLOYMENT_NAME durch den Namen des Bereitstellung.

Cloud Build

export DEPLOYMENT_NAME=[DEPLOYMENT_NAME]
export MANIFEST_NAME=$(gcloud deployment-manager deployments \
 describe $DEPLOYMENT_NAME \
  --project $PROJECT_ID --format="value(deployment.manifest)" |\
  grep -oEi "manifest-[0-9]+")
gcloud deployment-manager manifests describe $MANIFEST_NAME \
  --deployment $DEPLOYMENT_NAME --project $PROJECT_ID \
  --format="value(expandedConfig)" > deployment.yaml

# Grant additional roles to allow the Cloud Build service account to manage the
# resources in your deployment. For a list of roles, see
# https://cloud.google.com/iam/docs/understanding-roles.
# For example:
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
--role=roles/pubsub.editor

# Alternatively, you may grant roles/editor for testing purposes:
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
--role=roles/editor

Alternativ

# Configure your project/deployment
DEPLOYMENT_NAME=foo
PROJECT_ID=bar

# Fetch the latest manifest for the given deployment
gcloud deployment-manager deployments describe $DEPLOYMENT_NAME \
  --project $PROJECT_ID --format="value(deployment.manifest)"
https://www.googleapis.com/deploymentmanager/v2/projects/$PROJECT_ID/global/deployments/bq/manifests/manifest-1618872644848

# The manifest name is the last path segment from the URI
# in the above command output
MANIFEST_NAME="manifest-1618872644848"
# Save the expanded manifest to file ./$DEPLOYMENT_NAME.yaml
gcloud deployment-manager manifests describe $MANIFEST_NAME \
  --deployment $DEPLOYMENT_NAME --project $PROJECT_ID \
  --format="value(expandedConfig)" > $DEPLOYMENT_NAME.yaml

Nachdem Sie die Datei gespeichert haben, kopieren Sie sie in den zuvor erstellten Cloud Storage-Bucket:

gsutil cp ./deployment.yaml $DM_CONFIG_URI/deployment.yaml

Vorhandene Bereitstellung konvertieren

In diesem Leitfaden wird Cloud Build für den Conversion-Prozess verwendet.

Die Build-Definition liest die Deployment Manager-Konfiguration aus dem Cloud Storage-Bucket $DM_CONFIG_URI, konvertiert sie in das KRM- oder Terraform-Format und speichert die Ausgabe im selben Cloud Storage-Bucket.

Kopieren Sie den folgenden Inhalt in eine Datei mit dem Namen cloudbuild_convert.yaml:

steps:
- id: '[FETCH_DM_CONFIG]'
  name: 'gcr.io/cloud-builders/gsutil'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      mkdir dm
      gsutil cp "${_BUCKET_URI}/dm/*" dm/.
      mkdir "${_OUTPUT_FORMAT}"

- id: '[CONVERT_DM_CONFIG]'
  name: '${_DM_CONVERT_IMAGE}'
  args: ['--config', './dm/deployment.yaml',
         '--project_id', '${PROJECT_ID}',
          '--project_number', '${PROJECT_NUMBER}',
          '--output_format', '${_OUTPUT_FORMAT}',
          '--output_file', '${_OUTPUT_FORMAT}/${_OUTPUT_FILE}',
          '--deployment_name', '${_DEPLOYMENT_NAME}']

- id: '[EXPORT_OUTPUT_TO_STORAGE_BUCKET]'
  name: 'gcr.io/cloud-builders/gsutil'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      gsutil cp "${_OUTPUT_FORMAT}/${_OUTPUT_FILE}" \
        "${_BUCKET_URI}/output/${_OUTPUT_FILE}"

Sie können Cloud Build aus demselben Ordner wie cloudbuild_convert.yaml aufrufen, indem Sie die folgenden Parameter angeben:

  • _BUCKET_URI: Der Cloud Storage-Bucket, aus dem eine Deployment Manager-Konfiguration gelesen und in die konvertierte Ausgabe gespeichert werden soll.

  • _OUTPUT_FORMAT: Das Ausgabeformat für die Conversion. Dies kann entweder KRM für KRM oder TF für Terraform sein.

  • _OUTPUT_FILE: Der Name der Datei, in die die konvertierte Ausgabe im Cloud Storage-Bucket gespeichert werden soll.

  • _DM_CONVERT_IMAGE: Das zu verwendende Container-Image.

  • _DEPLOYMENT_NAME: Der Name des Deployments. Dies ist relevant, wenn Sie Vorlagen in Ihrer Deployment Manager-Konfiguration sowie die Umgebungsvariable deployment verwenden. Weitere Informationen finden Sie unter Umgebungsvariable verwenden.

Beispiel-Conversions

KRM-Datei

Führen Sie den folgenden Befehl aus, um die Konfiguration in das KRM-Format zu konvertieren und in $BUCKET_URI/output/krm_resources.yaml zu speichern:

export KRM_RESOURCES=krm_resources.yaml

gcloud builds submit . --config cloudbuild_convert.yaml \
--substitutions=_DM_CONVERT_IMAGE=$DM_CONVERT_IMAGE,_BUCKET_URI=$BUCKET_URI,\
_DEPLOYMENT_NAME=test-conversion-to-krm,\
_OUTPUT_FORMAT=KRM,_OUTPUT_FILE=$KRM_RESOURCES

# Print output file
gsutil cat $BUCKET_URI/output/$KRM_RESOURCES

Terraform

Führen Sie den folgenden Befehl aus, um die Konfiguration in das HCL-Format zu konvertieren und als $BUCKET_URI/output/tf_resources.tf zu speichern:

export TF_RESOURCES=tf_resources.tf

gcloud builds submit . --config cloudbuild_convert.yaml \
--substitutions=_DM_CONVERT_IMAGE=$DM_CONVERT_IMAGE,_BUCKET_URI=$BUCKET_URI,\
_DEPLOYMENT_NAME=test-conversion-to-tf,\
_OUTPUT_FORMAT=TF,_OUTPUT_FILE=$TF_RESOURCES

# Print output file
gsutil cat $BUCKET_URI/output/$TF_RESOURCES

Konvertierte Konfiguration anwenden

KRM-Datei

Config Connector einrichten

Zum Aktivieren der Ressourcen in den KRM-Konfigurationsdateien benötigen Sie einen Kubernetes-Cluster mit installiertem Config Connector. Informationen zum Erstellen eines Testclusters finden Sie unter Mit dem GKE-Add-on installieren.

Prüfen Sie in Cloud Shell, ob Ihre kubectl-Anmeldedaten für den GKE-Cluster konfiguriert sind, den Sie verwenden möchten. Ersetzen Sie GKE_CLUSTER durch den Namen des Clusters und führen Sie den folgenden Befehl aus:

gcloud container clusters get-credentials GKE_CLUSTER

Konvertierte KRM-Konfiguration mit kubectl bereitstellen

Führen Sie die folgenden Befehle aus, um Ihre konvertierte KRM-Konfiguration mit kubectl bereitzustellen:

# Copy the converted configuration from the storage bucket
gsutil cp $BUCKET_URI/output/$KRM_RESOURCES $KRM_RESOURCES

# Replace [CONFIG_CONNECTOR_NAMESPACE] with your namespace
export KCC_NAMESPACE=[CONFIG_CONNECTOR_NAMESPACE]

kubectl apply -n $KCC_NAMESPACE -f $KRM_RESOURCES

# Wait for the resources to become healthy
kubectl wait -n $KCC_NAMESPACE --for=condition=Ready \
  --timeout=5m -f $KRM_RESOURCES

Terraform

Terraform einrichten

Verwenden Sie den zuvor erstellten Cloud Storage-Bucket, um Terraform mit Ihrem Google Cloud-Projekt zu konfigurieren:

# Configure default project
cat <<EOF > echo > main.tf
provider "google" {
project = "$PROJECT_ID"
}
EOF

# Configure Cloud Storage remote backend to store state in gs://$BUCKET_NAME/tfstate
cat <<EOF > echo > backend.tf
terraform {
backend "gcs" {
  bucket = "$BUCKET_NAME"
  prefix = "tfstate"
}
}
EOF

Konvertierte Konfiguration mit Terraform bereitstellen

Erstellen Sie im selben Ordner wie die zuvor erstellten Dateien main.tf und backend.tf eine lokale Datei mit dem Namen cloudbuild_tf.yaml und kopieren Sie Folgendes hinein:

steps:
- id: '[FETCH_DM_CONFIG]'
  name: 'gcr.io/cloud-builders/gsutil'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      # Fetch the latest manifest for the given deployment
      gsutil cp $_BUCKET_URI/output/*.tf .

- id: '[APPLY_USING_TERRAFORM]'
  name: 'hashicorp/terraform'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      echo "***************  TERRAFORM INIT  ******************"
      # NOTE: if Terraform state gets corrupted during testing,
      # use init --reconfigure to reset backend
      terraform init
      echo "***************  TERRAFORM PLAN  ******************"
      terraform plan
      echo "**************  TERRAFORM APPLY  ******************"
      terraform apply --auto-approve

Vorhandene Ressourcen importieren

Wenn Sie eine vorhandene Bereitstellung konvertieren, verwenden Sie terraform import RESOURCE_TYPE RESOURCE_ID, um die vorhandenen Ressourcen zu importieren, anstatt sie noch einmal mithilfe von terraform apply bereitzustellen.

Beispiel für eine vorhandene Bereitstellung:

resources:
  - type: pubsub.v1.topic
    name: sample-pubsub-topic
    properties:
      topic: sample-pubsub-topic
  - type: pubsub.v1.subscription
    name: sample-pubsub-subscription
    properties:
      topic: $(ref.sample-pubsub-topic.name)
      subscription: sample-pubsub-subscription

Gemäß dem Abschnitt import der Terraform-Dokumentation für google_pubsub_topic kann terraform import in einem der folgenden Formate:

$ terraform import google_pubsub_topic.default projects/PROJECT_NAME/topics/NAME
$ terraform import google_pubsub_topic.default PROJECT_NAME/NAME
$ terraform import google_pubsub_topic.default NAME

Nehmen Sie die folgenden Ersetzungen vor:

  • PROJECT_NAME ist die Projekt-ID.

  • NAME ist der Name der Deployment Manager-Ressource, z. B. sample-pubsub-topic.

  • default ist der Terraform-Ressourcenname. Dies ist der Deployment Manager-Ressourcenname, wobei alle --Zeichen durch _ ersetzt werden. Sie können den Ressourcennamen auch mit gsutil cat $BUCKET_URI/output/$TF_RESOURCES ermitteln, um die konvertierte Terraform-Konfiguration zu prüfen.

Nachdem Sie die Ersetzungen vorgenommen haben, sollte Ihr Befehl in etwa so aussehen:

$ terraform import google_pubsub_topic.sample_pubsub_topic
$PROJECT_ID/sample-pubsub-topic

Die Terraform-Dokumentation für google_pubsub_subscription zeigt die folgenden möglichen Formate:

$ terraform import google_pubsub_subscription.default projects/PROJECT_NAME/subscriptions/NAME
$ terraform import google_pubsub_subscription.default PROJECT_NAME/NAME
$ terraform import google_pubsub_subscription.default NAME

Ein möglicher terraform import-Befehl ist:

$ terraform import google_pubsub_subscription.sample_pubsub_subscription
$PROJECT_ID/sample-pubsub-subscription

Die Cloud Build-Definition für diesen Befehl lautet:

steps:
- id: '[FETCH_DM_CONFIG]'
  name: 'gcr.io/cloud-builders/gsutil'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      # Fetch the latest manifest for the given deployment
      gsutil cp $_BUCKET_URI/output/*.tf .

- id: '[APPLY_USING_TERRAFORM]'
  name: 'hashicorp/terraform'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      echo "***************  TERRAFORM INIT  ******************"
      # NOTE: if Terraform state gets corrupted during testing,
      # use init --reconfigure to reset backend
      terraform init
      echo "***************  TERRAFORM PLAN  ******************"
      terraform plan
      echo "**************  TERRAFORM IMPORT  ******************"
      terraform import google_pubsub_topic.sample_pubsub_topic $PROJECT_ID/sample-pubsub-topic
      terraform import google_pubsub_subscription.sample_pubsub_subscription $PROJECT_ID/sample-pubsub-subscription

Optional können Sie Deployment Manager verwenden, um die Bereitstellung zu löschen und die Bereitstellung mit Terraform mit terraform apply neu zu erstellen.

Sie können Cloud Build aus demselben Ordner wie die zuvor erstellte Datei aufrufen. Geben Sie dazu die folgenden Parameter an:

  • _BUCKET_URI: Der Storage-Bucket, in dem Sie die konvertierte Terraform-Konfiguration gespeichert haben.
gcloud builds submit . --config cloudbuild_tf.yaml \
--substitutions=_BUCKET_URI=$BUCKET_URI

Bereinigen

Beispiel-Dataset und -Tabelle bereinigen

KRM-Datei

Führen Sie folgenden Befehl aus, um das BigQuery-Dataset und die Tabelle aus der Beispielkonfiguration zu bereinigen:

# If the resource was created via Config Connector:
kubectl delete -n $KCC_NAMESPACE -f $KRM_RESOURCES

Terraform

Speichern Sie die folgende Cloud Build-Definition in cloudbuild_tf_destroy.yaml:

# If the resource was created via Terraform, save the following Cloud Build steps into cloudbuild_tf_destroy.yaml:
steps:
- id: '[FETCH_DM_CONFIG]'
  name: 'gcr.io/cloud-builders/gsutil'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      # Fetch the latest manifest for the given deployment
      gsutil cp $_BUCKET_URI/output/*.tf .

- id: '[DESTROY_USING_TERRAFORM]'
  name: 'hashicorp/terraform'
  entrypoint: 'sh'
  args:
  - '-c'
  - |
      echo "***************  TERRAFORM INIT  ******************"
      terraform init
      # NOTE: if Terraform state gets corrupted during testing,
      # use init --reconfigure to reset backend

      # Remove delete protection on BigQuery table
      sed -i "/resource \"google_bigquery_table\"/a deletion_protection=\"false\"" tf_resources.tf
      terraform apply --auto-approve

      echo "***************  TERRAFORM DESTROY ****************"
      terraform destroy --auto-approve

Führen Sie nach dem Speichern der Definition den folgenden Befehl aus:

gcloud builds submit . --config cloudbuild_tf_destroy.yaml \
--substitutions=_BUCKET_URI=$BUCKET_URI

Deployment bereinigen

Zum Verwerfen einer Live-Bereitstellung, die Sie in KRM oder Terraform konvertiert haben, führen Sie Folgendes aus:

gcloud deployment-manager deployments delete DEPLOYMENT_NAME --delete-policy ABANDON