Guide to Deploy Collate Binaries in GCP

This guide will help you start using Collate Docker Images to run the Collate OpenMetadata Application in Kubernetes on Google Kubernetes Engine, connecting with Argo Workflows for running ingestion from the Collate OpenMetadata Application itself.

Architecture

Collate OpenMetadata requires four components:

Collate Server.
Database: Collate Server stores the metadata in a relational database. Collate supports Postgres. GCP Cloud SQL is recommended for production.
- Postgres version 17.6 or greater.
Search Engine: OpenSearch 3.4. ElasticSearch is not supported in Collate BYOC because Collate AI relies on OpenSearch’s vector capabilities for Semantic and Hybrid Search.
Workflow Orchestration: Collate uses Argo Workflows as the orchestrator for ingestion pipelines.

Note: GKE Autopilot mode restricts elevated permissions required by some workloads. Use GKE Standard mode for Collate deployments.

Sizing Requirements

The following sections cover hardware, software, and per-component sizing recommendations for a production-ready deployment.

Hardware Requirements

A GKE Standard cluster with a managed control plane and at least five worker nodes is the required configuration. Each worker node should have at least:

4 vCPUs.
16 GiB Memory.
128 GiB Storage capacity.

Software Requirements

Collate OpenMetadata supports Kubernetes cluster version 1.29 or greater.
Collate Docker Images are available via private AWS Elastic Container Registry (ECR). The Collate Team will share credentials and steps to configure Kubernetes to pull Docker Images from AWS ECR.
For Argo Workflows, Collate OpenMetadata is currently compatible with application version 3.4+.

Recommended GKE Instance Types

Component	Instance Type
GKE Node Pools	t2a-standard-4 / t2d-standard-4 or similar

Database Sizing and Capacity

Collate recommends configuring Cloud SQL Postgres. For 100,000 Data Assets and 1,000 Users:

8 vCPUs.
64 GiB Memory.
256 GiB Storage Capacity.
High availability (multi-zone) recommended.

Component	Instance Type
Cloud SQL Postgres	db-custom-8-65536 or similar

Important: Make sure to increase work_mem (for Postgres) to 20 MB or more. This is especially important when running migrations to prevent Out of Sort Memory errors. For more information about configuring Postgres flags, see Cloud SQL flags.Enable the following extensions in the database:

pg_stat_statements (for query performance monitoring).
pg_trgm (for faster search performance).
pgcrypto (for encryption capabilities).

Search Client Sizing and Capacity

For 100,000 Data Assets and 1,000 Users:

8 vCPUs.
64 GiB Memory.
256 GiB Storage Capacity.

A managed OpenSearch offering is the recommended search option for production. Run OpenSearch directly inside Kubernetes as well.

Note: The Collate team does not maintain OpenSearch when run inside Kubernetes.

Argo Workflows Ingestion Runners

The recommended resources are 4 vCPUs and 16 GiB of Memory. Ingestion workloads can be scheduled on preemptible/spot instances to reduce costs.

Prerequisites

The following steps configure the GCP project, GKE cluster, and service accounts Collate needs before installation.

Enable the Required GCP Project APIs

Enable the following APIs in your GCP project:

Backup for GKE API (gkebackup.googleapis.com).
Certificate Manager API (certificatemanager.googleapis.com).
Cloud Autoscaling API (autoscaling.googleapis.com).
Cloud DNS API (dns.googleapis.com).
Cloud Key Management Service (KMS) API (cloudkms.googleapis.com).
Cloud Logging API (logging.googleapis.com).
Cloud Monitoring API (monitoring.googleapis.com).
Cloud Resource Manager API (cloudresourcemanager.googleapis.com).
Cloud SQL (sql-component.googleapis.com).
Cloud SQL Admin API (sqladmin.googleapis.com).
Cloud Storage API (storage-component.googleapis.com).
Compute Engine API (compute.googleapis.com).
Container File System API (containerfilesystem.googleapis.com).
Container Registry API (containerregistry.googleapis.com).
Gemini API (generativelanguage.googleapis.com).
Google Cloud Storage JSON API (storage-api.googleapis.com).
IAM Service Account Credentials API (iamcredentials.googleapis.com).
Identity and Access Management (IAM) API (iam.googleapis.com).
Kubernetes Engine API (container.googleapis.com).
Network Connectivity API (networkconnectivity.googleapis.com).
Network Security API (networksecurity.googleapis.com).
Network Services API (networkservices.googleapis.com).
Secret Manager API (secretmanager.googleapis.com).
Service Management API (servicemanagement.googleapis.com).
Service Networking API (servicenetworking.googleapis.com).
Service Usage API (serviceusage.googleapis.com).

Enable GKE Workload Identity

Workload Identity allows Kubernetes service accounts to act as GCP service accounts, eliminating the need for static credentials. Check if Workload Identity is enabled on your cluster:

gcloud container clusters describe <CLUSTER_NAME> \
  --region <REGION> \
  --format="value(workloadIdentityConfig.workloadPool)"

If not enabled, update the cluster:

gcloud container clusters update <CLUSTER_NAME> \
  --region <REGION> \
  --workload-pool=<PROJECT_ID>.svc.id.goog

Also enable Workload Identity on the node pool:

gcloud container node-pools update <NODE_POOL_NAME> \
  --cluster <CLUSTER_NAME> \
  --region <REGION> \
  --workload-metadata=GKE_METADATA

Create a GCS Bucket for Argo Workflows Artifacts

Argo Workflows archives ingestion logs to Google Cloud Storage:

gcloud storage buckets create gs://collate-argo-artifacts-<PROJECT_ID> --location=<REGION>

Create GCP Service Accounts

Collate requires three GCP service accounts for the Collate Server, Collate Ingestion, and Argo Workflows:

# For Collate Server Application
gcloud iam service-accounts create collate-server-sa \
  --display-name="Collate Server Application" \
  --project="${PROJECT_ID}"

# For Collate Ingestion
gcloud iam service-accounts create collate-ingestion-sa \
  --display-name="Collate Ingestion" \
  --project="${PROJECT_ID}"

# For Argo Workflows
gcloud iam service-accounts create argo-workflows-sa \
  --display-name="Argo Workflows Service Account" \
  --project="${PROJECT_ID}"

Grant GCS Access to GCP Service Accounts

Grant each GCP service account the storage permissions it needs on the Argo Workflows artifacts bucket:

# Argo Workflows — read/write for workflow logs
gcloud storage buckets add-iam-policy-binding gs://collate-argo-artifacts-${PROJECT_ID} \
  --member="serviceAccount:argo-workflows-sa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/storage.objectAdmin"

# Collate Server — read/write for asset uploads
gcloud storage buckets add-iam-policy-binding gs://collate-argo-artifacts-${PROJECT_ID} \
  --member="serviceAccount:collate-server-sa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/storage.objectAdmin"

# Collate Ingestion — read/write for artifact access
gcloud storage buckets add-iam-policy-binding gs://collate-argo-artifacts-${PROJECT_ID} \
  --member="serviceAccount:collate-ingestion-sa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/storage.objectAdmin"

Bind GCP Service Accounts to Kubernetes Service Accounts with Workload Identity

Bind the GCP service accounts to Kubernetes service accounts using Workload Identity. This allows applications running in Kubernetes to authenticate with GCP services using the associated GCP service account without needing static credentials.

Note: The following command assumes the Kubernetes service accounts are created in the argo-workflows and collate namespaces with the names argo-workflows-controller-sa, argo-workflows-server-sa, and om-role respectively. Adjust the service account names and namespaces based on your configuration.

# Argo Workflows Controller
gcloud iam service-accounts add-iam-policy-binding \
  argo-workflows-sa@${PROJECT_ID}.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[argo-workflows/argo-workflows-controller-sa]"

# Argo Workflows Server
gcloud iam service-accounts add-iam-policy-binding \
  argo-workflows-sa@${PROJECT_ID}.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[argo-workflows/argo-workflows-server-sa]"

# Collate Server Application
gcloud iam service-accounts add-iam-policy-binding \
  collate-server-sa@${PROJECT_ID}.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[collate/openmetadata]"

# Collate Ingestion
gcloud iam service-accounts add-iam-policy-binding \
  collate-ingestion-sa@${PROJECT_ID}.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[collate/om-role]"

Grant GCP Service Accounts Access to Cloud SQL

The configuration in this guide is based on Cloud SQL for Postgres as the database for Collate with IAM Authentication enabled. For more information about how to set up IAM Authentication, see IAM Authentication. Collate recommends using a single Cloud SQL instance for both Collate Server and Argo Workflows. The instance should have IAM Authentication enabled, with separate databases created for Collate Server and Argo Workflows.

Note: If you are using separate Cloud SQL instances for Collate Server and Argo Workflows, ensure you grant access to both instances for the respective service accounts.

Note: IAM database users created for Cloud SQL Postgres are regular Postgres roles. They are not database owners and do not get CREATE privileges on existing databases by default. After creating the IAM users, connect as an admin user and grant CREATE on the respective databases, for example:

GRANT CREATE ON DATABASE <OPENMETADATA_DB_NAME> TO "<COLLATE_SERVER_IAM_DB_USER>";
GRANT CREATE ON DATABASE <ARGO_WORKFLOWS_DB_NAME> TO "<ARGO_WORKFLOWS_IAM_DB_USER>";

# Grant access to Collate Server Application Service Account
gcloud sql users create "collate-server-sa@${PROJECT_ID}.iam" \
  --instance=<CLOUD_SQL_INSTANCE_NAME> \
  --project=${PROJECT_ID} \
  --host=% \
  --type=cloud_iam_service_account

# Grant access to Argo Workflows Service Account
gcloud sql users create "argo-workflows-sa@${PROJECT_ID}.iam" \
  --instance=<CLOUD_SQL_INSTANCE_NAME> \
  --project=${PROJECT_ID} \
  --host=% \
  --type=cloud_iam_service_account

# Bind the service accounts to the Cloud SQL instance with appropriate roles
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:collate-server-sa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:collate-server-sa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.instanceUser"

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:argo-workflows-sa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.client"

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:argo-workflows-sa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/cloudsql.instanceUser"

Note: Replace <CLOUD_SQL_INSTANCE_NAME> with the name of your Cloud SQL instance.

Note: These SQL users will be used by the Collate Server and Argo Workflows to authenticate with the Cloud SQL instance using IAM Authentication. In Kubernetes, the configuration uses Cloud SQL Proxy to connect to the Cloud SQL instance securely without exposing the instance publicly.

Set Up AWS ECR

Collate will provide the credentials to pull Docker Images from a private registry located in AWS ECR.

Install AWS CLI

Follow the AWS CLI installation guide to install AWS CLI on your machine.

Configure AWS Credentials

Configure the AWS CLI with the credentials for the ECR profile:

aws configure --profile ecr-collate

The command will prompt for credentials. The Collate team will securely share these via a 1Password link. Confirm the credentials are correctly set:

aws configure list --profile ecr-collate

Kubernetes Docker Registry Secrets for AWS ECR

Create a Kubernetes secret so the cluster can pull images from the private ECR registry:

kubectl create secret docker-registry ecr-registry-creds \
  --docker-server=118146679784.dkr.ecr.eu-west-1.amazonaws.com \
  --docker-username=AWS \
  --docker-password=$(aws ecr get-login-password --profile ecr-collate) \
  --namespace <<NAMESPACE_NAME>>

Note: Replace <<NAMESPACE_NAME>> with the namespace where you want to deploy Collate OpenMetadata Server. If the namespace does not exist yet, create it with kubectl create namespace <<NAMESPACE_NAME>>.

ECR authentication tokens are short-lived, so plan to refresh them periodically.

Important: AWS ECR Token RefreshECR tokens expire after 12 hours. If a pod is rescheduled after 12 hours, you will get an ImagePullBackOff error. Delete the secret and recreate it using the docker-registry secret creation command.

Install Argo Workflows

Install Argo Workflows using its Helm chart, then configure it to work with Collate ingestion.

Add Helm Repository

Add the community Argo Workflows Helm repository:

helm repo add argo https://argoproj.github.io/argo-helm
helm repo update

Create the Argo Namespace

Create a dedicated namespace for Argo Workflows:

kubectl create namespace argo-workflows

Kubernetes Secret for Argo Workflows DB Credentials

Create a Kubernetes secret with the database credentials Argo Workflows will use:

kubectl create secret generic argo-db-credentials \
  --from-literal=username=<DB_USERNAME> \
  --from-literal=password="dummy-password" \
  --namespace argo-workflows

Create Custom Helm Values for Argo Workflows

Create a file named argo-workflows.values.yml:

# argo-workflows.values.yml
controller:
  serviceAccount:
    create: true
    name: argo-workflows-controller-sa
    annotations:
      iam.gke.io/gcp-service-account: "argo-workflows-sa@<PROJECT_ID>.iam.gserviceaccount.com"
  name: workflow-controller
  resources:
    requests:
      memory: "2Gi"
      cpu: "1"
    limits:
      memory: "4Gi"
      cpu: "2"
  persistence:
    archive: true
    connectionPool:
      maxIdleConns: 40
      maxOpenConns: 60
    postgresql:
      host: 127.0.0.1
      database: argo-workflows
      tableName: argo_workflows
      userNameSecret:
        name: argo-db-credentials
        key: username
      passwordSecret:
        name: argo-db-credentials
        key: password
  extraContainers:
  - name: cloud-sql-proxy
    image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.3
    args:
      - "--private-ip"
      - "--auto-iam-authn"
      - "--structured-logs"
      - "--port=5432"
      - "${DATABASE_INSTANCE_CONNECTION_NAME}"
    securityContext:
      runAsNonRoot: true
    resources:
      requests:
        memory: "2Gi"
        cpu: "1"

server:
  serviceAccount:
    create: true
    name: argo-workflows-server-sa
    annotations:
      iam.gke.io/gcp-service-account: "argo-workflows-sa@<PROJECT_ID>.iam.gserviceaccount.com"
  extraArgs:
    - "--auth-mode=server"
    - "--request-timeout=5m"
  extraContainers:
  - name: cloud-sql-proxy
    image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.3
    args:
      - "--private-ip"
      - "--auto-iam-authn"
      - "--structured-logs"
      - "--port=5432"
      - "${DATABASE_INSTANCE_CONNECTION_NAME}"
  resources:
    requests:
      memory: "2Gi"
      cpu: "1"
    limits:
      memory: "2Gi"
      cpu: "1"

useDefaultArtifactRepo: true
artifactRepository:
  archiveLogs: true
  gcs:
    bucket: "collate-argo-artifacts-<PROJECT_ID>"
    keyFormat: "workflows/{{workflow.namespace}}/{{workflow.name}}/{{pod.name}}"

For further customisation, refer to the community Helm chart values.

Deploy Argo Workflows

Collate targets application version 3.7.1 using Helm chart version 0.45.23 (Artifact Hub):

helm upgrade --install argo-workflows argo/argo-workflows \
  --version 0.45.23 \
  --namespace argo-workflows \
  --values argo-workflows.values.yml

Optional: Enable Prometheus Metrics

If you have a Prometheus Application running on your cluster, enable metrics using:

controller:
  serviceMonitor:
    enabled: true
server:
  serviceMonitor:
    enabled: true

Refer to the official Argo Workflows documentation for further configuration.

Install Collate

With Argo Workflows in place, install the Collate OpenMetadata application into the cluster.

Create the Collate Namespace

Create a namespace to host the Collate deployment:

kubectl create namespace collate

Kubernetes Service Account for Ingestion

Create a dedicated Kubernetes service account that Collate uses to trigger ingestion workflows:

kubectl create serviceaccount om-role -n collate

Annotate Service Account with Workload Identity

Annotate the service account so it can authenticate as the associated GCP service account:

kubectl annotate serviceaccount -n collate om-role \
  iam.gke.io/gcp-service-account=collate-ingestion-sa@${PROJECT_ID}.iam.gserviceaccount.com

Create Long-Lived API Token for the Service Account

Create a long-lived token secret for the service account:

kubectl apply -n collate -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  name: om-role.service-account-token
  annotations:
    kubernetes.io/service-account.name: om-role
type: kubernetes.io/service-account-token
EOF

Configure Kubernetes Roles for the Service Account

Create a file om-argo-role.yml:

# om-argo-role.yml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: om-argo-role
  namespace: collate
rules:
  - verbs: [list, watch, create, update, patch, get, delete]
    apiGroups:
      - argoproj.io
    resources:
      - workflows
  - verbs: [list, watch, patch, get]
    apiGroups:
      - ''
    resources:
      - pods/log
      - pods
  - verbs: [list, watch, create, update, patch, get, delete]
    apiGroups:
      - argoproj.io
    resources:
      - cronworkflows
  - verbs: [create, patch]
    apiGroups:
      - argoproj.io
    resources:
      - workflowtaskresults

Apply the role and create the role binding:

kubectl apply -f om-argo-role.yml

kubectl create rolebinding om-argo-role-binding \
  --role=om-argo-role \
  --serviceaccount=collate:om-role \
  --namespace collate

Install the Collate Helm Chart

Create Kubernetes Secrets for the database connection:

kubectl create secret generic db-credentials \
  --from-literal=password="dummy-password" \
  --namespace collate

Add the Helm chart repository:

helm repo add open-metadata https://helm.open-metadata.org/
helm repo update

Note: If you plan to use the DeltaLake connector, the ARGO_INGESTION_IMAGE value should be: 118146679784.dkr.ecr.eu-west-1.amazonaws.com/collate-customers-ingestion-eu-west-1:om-1.13.0-cl-1.13.0

Create a file openmetadata.values.yml:

# openmetadata.values.yml
replicaCount: 1
openmetadata:
  config:
    elasticsearch:
      host: ${es_host}
      port: ${es_port}
      scheme: ${es_scheme}
      searchType: opensearch
      auth:
        enabled: true
        username: ${es_username}
        password:
          secretRef: es-credentials
          secretKey: password
    database:
      host: 127.0.0.1
      port: 5432
      driverClass: org.postgresql.Driver
      dbScheme: postgresql
      maxSize: 100
      minSize: 40
      initialSize: 20
      auth:
        username: ${db_user}
        password:
          secretRef: db-credentials
          secretKey: password
      dbParams: "sslmode=require"
    pipelineServiceClientConfig:
      enabled: true
      type: "argoWorkflows"
      metadataApiEndpoint: "http://openmetadata:8585/api"
      argoWorkflows:
        namespace: collate
        serviceAccountName: om-role
        ingestionImage: "118146679784.dkr.ecr.eu-west-1.amazonaws.com/collate-customers-ingestion-slim-eu-west-1:om-1.13.0-cl-1.13.0"
        imagePullPolicy: "IfNotPresent"
        imagePullSecrets: "ecr-registry-creds"
        apiEndpoint: "http://argo-workflows-server.argo-workflows:2746"
image:
  repository: 118146679784.dkr.ecr.eu-west-1.amazonaws.com/collate-customers-eu-west-1
  tag: om-1.13.0-cl-1.13.0
  imagePullPolicy: IfNotPresent
imagePullSecrets:
  - name: ecr-registry-creds
resources:
  limits:
    cpu: 3000m
    memory: 12Gi
  requests:
    cpu: 1000m
    memory: 10Gi
extraEnvs:
  - name: ARGO_TOKEN
    valueFrom:
      secretKeyRef:
        name: "om-role.service-account-token"
        key: "token"
  - name: OPENMETADATA_HEAP_OPTS
    value: "-Xmx8G -Xms8G"
preMigrateInitContainers:
- name: cloud-sql-proxy
  image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.3
  restartPolicy: Always
  args:
    - "--private-ip"
    - "--auto-iam-authn"
    - "--structured-logs"
    - "--port=5432"
    - "${DATABASE_INSTANCE_CONNECTION_NAME}"
  securityContext:
    runAsNonRoot: true
  resources:
    requests:
      memory: "2Gi"
      cpu: "1"
serviceAccount:
  name: "openmetadata"
  create: true
  annotations:
    iam.gke.io/gcp-service-account: "collate-server-sa@<PROJECT_ID>.iam.gserviceaccount.com"

Install the Collate OpenMetadata Application:

helm upgrade --install openmetadata open-metadata/openmetadata \
  --values openmetadata.values.yml \
  --namespace collate

Optional: Enable Prometheus Metrics

Collate Application exposes Prometheus metrics on port 8586. Enable the integration using:

serviceMonitor:
  enabled: true

Post-Installation and Upgrade Steps

Complete the following step after installing or upgrading Collate.

Configure Reindexing

After installation or upgrade, configure ReIndexing from the Collate UI. For detailed steps, refer to the Reindexing Search guide.

Appendix: List of AWS ECR Public IPs

If your company policy blocks access to external resources, ensure the public IPs of AWS ECR are reachable from your cluster.

Using curl and jq

Query the AWS IP ranges for the ECR region using curl and jq:

curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq '.prefixes[] | select(.region=="eu-west-1") | select(.service=="AMAZON")'

​Guide to Deploy Collate Binaries in GCP

​Architecture

​Sizing Requirements

​Hardware Requirements

​Software Requirements

​Recommended GKE Instance Types

​Database Sizing and Capacity

​Search Client Sizing and Capacity

​Argo Workflows Ingestion Runners

​Prerequisites

​Enable the Required GCP Project APIs

​Enable GKE Workload Identity

​Create a GCS Bucket for Argo Workflows Artifacts

​Create GCP Service Accounts

​Grant GCS Access to GCP Service Accounts

​Bind GCP Service Accounts to Kubernetes Service Accounts with Workload Identity

​Grant GCP Service Accounts Access to Cloud SQL

​Set Up AWS ECR

​Install AWS CLI

​Configure AWS Credentials

​Kubernetes Docker Registry Secrets for AWS ECR

​Install Argo Workflows

​Add Helm Repository

​Create the Argo Namespace

​Kubernetes Secret for Argo Workflows DB Credentials

​Create Custom Helm Values for Argo Workflows

​Deploy Argo Workflows

​Optional: Enable Prometheus Metrics

​Install Collate

​Create the Collate Namespace

​Kubernetes Service Account for Ingestion

​Annotate Service Account with Workload Identity

​Create Long-Lived API Token for the Service Account

​Configure Kubernetes Roles for the Service Account

​Install the Collate Helm Chart

​Optional: Enable Prometheus Metrics

​Post-Installation and Upgrade Steps

​Configure Reindexing

​Appendix: List of AWS ECR Public IPs

​Using curl and jq

Guide to Deploy Collate Binaries in GCP

Architecture

Sizing Requirements

Hardware Requirements

Software Requirements

Recommended GKE Instance Types

Database Sizing and Capacity

Search Client Sizing and Capacity

Argo Workflows Ingestion Runners

Prerequisites

Enable the Required GCP Project APIs

Enable GKE Workload Identity

Create a GCS Bucket for Argo Workflows Artifacts

Create GCP Service Accounts

Grant GCS Access to GCP Service Accounts

Bind GCP Service Accounts to Kubernetes Service Accounts with Workload Identity

Grant GCP Service Accounts Access to Cloud SQL

Set Up AWS ECR

Install AWS CLI

Configure AWS Credentials

Kubernetes Docker Registry Secrets for AWS ECR

Install Argo Workflows

Add Helm Repository

Create the Argo Namespace

Kubernetes Secret for Argo Workflows DB Credentials

Create Custom Helm Values for Argo Workflows

Deploy Argo Workflows

Optional: Enable Prometheus Metrics

Install Collate

Create the Collate Namespace

Kubernetes Service Account for Ingestion

Annotate Service Account with Workload Identity

Create Long-Lived API Token for the Service Account

Configure Kubernetes Roles for the Service Account

Install the Collate Helm Chart

Optional: Enable Prometheus Metrics

Post-Installation and Upgrade Steps

Configure Reindexing

Appendix: List of AWS ECR Public IPs

Using curl and jq