Admin: Add Navbox deployment template before Related (via update-page on MediaWiki MCP Server)

2026-07-06T04:00:39Z

Add Navbox deployment template before Related (via update-page on MediaWiki MCP Server)

← Older revision		Revision as of 09:30, 6 July 2026
Line 638:		Line 638:

	These steps will initiate the build pipeline for the backend and frontend projects across all the projects set up in the GitHub Secrets.		These steps will initiate the build pipeline for the backend and frontend projects across all the projects set up in the GitHub Secrets.

			{{Navbox deployment}}

	{{Related}}		{{Related}}

Admin: OHC identity seed

2026-07-04T23:08:24Z

OHC identity seed

New page

{{Doc header
|type=guide
|domain=deployment
|title=Deploying Care on GKE
|order=2
}}

This guide provides a step-by-step process for deploying the '''Care''' application on '''Google Cloud Platform (GCP)''' using '''Google Kubernetes Engine (GKE)'''. It combines the full infrastructure setup, the Cloud Build pipeline, and the deployment workflow into a single reference.

The deployment involves three phases:

* '''Infrastructure''' — provision the VPC, static IP, Cloud SQL databases, Cloud Storage buckets, and the GKE cluster.
* '''Build pipeline''' — set up Artifact Registry, Cloud Source Repositories, the <code>infra_template</code> configuration, and Cloud Build.
* '''Deploying''' — apply the Kubernetes manifests, configure DNS, and trigger releases manually or via GitHub Actions.

{{Info|1=For an overview of the GCP deployment options and infrastructure requirements, see the [[Index|Google Cloud overview]]. To host the Care frontend on Cloud Storage instead of GKE, see [[Gcs|Host the frontend on GCS]].}}

== Infrastructure ==

=== Setting up the network and creating a VPC ===

==== Creating a VPC network ====

# Go to '''VPC Network''' in '''Google Cloud Console'''.
# Click '''Create VPC network''' and name it <code>care-vpc</code>.
# Configure the following settings:
#* '''MTU''': <code>1460</code>
#* '''IPv6 Range''': Disabled
#* '''Subnet Creation Mode''': Custom

==== Creating a subnet ====

<ol start="4" style="list-style-type: decimal;">
<li>Create a new subnet with these details:
<ul>
<li>'''Name''': <code>cluster-snet</code></li>
<li>'''Region''': <code>asia-south1</code></li>
<li>'''IP Stack Type''': <code>IPv4 (single-stack)</code></li>
<li>'''IPv4 Range''': <code>10.0.0.0/16</code></li>
<li>'''Private Google Access''': On</li>
<li>'''Flow Logs''': Off</li></ul>
</li>
<li>Set '''Dynamic Routing Mode''' to <code>Regional</code>.</li>
<li>Keep the default firewall rules.</li></ol>

==== Command-line equivalent ====

To create the VPC and subnet using <code>gcloud</code>:

<syntaxhighlight lang="bash">gcloud compute networks create care-vpc --project=$PROJECT --subnet-mode=custom --mtu=1460 --bgp-routing-mode=regional
gcloud compute networks subnets create cluster-snet --project=$PROJECT --range=10.0.0.0/16 --stack-type=IPV4_ONLY --network=care-vpc --region=asia-south1 --enable-private-ip-google-access</syntaxhighlight>
==== Reserving a static IP address ====

# Navigate to '''VPC Networks > IP Addresses'''.
# Click '''RESERVE EXTERNAL STATIC IP ADDRESS'''.
# Configure the following:
#* '''Name''': <code>pip-care</code>
#* '''Network Service Tier''': <code>Premium</code>
#* '''IP Version''': <code>IPv4</code>
#* '''Type''': <code>Regional</code>
#* '''Region''': <code>asia-south1 (Mumbai)</code>
#* '''Attached to''': None
# Note down the assigned IP for future use.

Command-line equivalent:

<syntaxhighlight lang="bash">gcloud compute addresses create pip-care --project=$PROJECT --region=asia-south1</syntaxhighlight>
=== Setting up databases ===

==== Creating a Cloud SQL instance ====

# Go to '''Google Cloud Console''' > '''Cloud SQL'''.
# Click '''Create Instance''' and choose <code>PostgreSQL</code>.
# Configure the first database:
#* '''Instance ID''': <code>care-db</code>
#* '''Authentication''': Cloud SQL (set a strong master password)
#* '''Database Version''': <code>PostgreSQL 16</code>
#* '''Cloud SQL Edition''': Enterprise
#* '''Region''': <code>asia-south1</code> | '''Primary Zone''': <code>asia-south1-a</code>
#* '''Machine Type''': <code>2 vCPU, 8 GB RAM, 20 GB SSD</code>
#* '''Enable''': Automatic storage increases, backups, point-in-time recovery, deletion protection
#* '''Instance IP''': Private (assign to <code>care-vpc</code>)
# Create a database named <code>care</code>.
# Repeat for <code>metabase-db</code>, but configure it with:
#* '''Machine Type''': <code>1 vCPU, 3.75 GB RAM</code>
#* '''Database Name''': <code>metabase</code>

=== Configuring Cloud Storage ===

==== Creating buckets ====

# Go to '''Cloud Storage''' > '''Buckets''' > '''Create'''.
# Configure the first bucket:
#* '''Name''': <code><prefix>-care-facility</code>
#* '''Location''': <code>asia-south1 (Mumbai)</code>, <code>Standard</code>
#* '''Access Control''': Uniform
#* '''Public Access Prevention''': Off
# Configure the second bucket:
#* '''Name''': <code><prefix>-care-patient-data</code>
#* '''Public Access Prevention''': On
#* '''Retention Policy''': 7 days

==== Configuring the service account ====

# Navigate to '''Settings > Interoperability'''.
# Create a service account <code>care-bucket-access</code> with role <code>Storage Object Admin</code>.
# Generate access keys and note them for later use.

==== Configuring CORS for Cloud Storage ====

For <code><prefix>-care-facility</code>:

<syntaxhighlight lang="json">[
{
"origin": ["*"],
"responseHeader": ["Content-Type"],
"method": ["GET", "HEAD", "PUT", "POST", "DELETE"],
"maxAgeSeconds": 3600
}
]</syntaxhighlight>
For <code><prefix>-care-patient-data</code>:

<syntaxhighlight lang="json">[
{
"origin": ["care.example.com"],
"responseHeader": ["Content-Type"],
"method": ["GET", "HEAD", "PUT", "POST", "DELETE"],
"maxAgeSeconds": 3600
}
]</syntaxhighlight>
Command-line equivalent:

<syntaxhighlight lang="bash">gsutil cors set cors.json gs://<prefix>-care-facility
gsutil cors set cors.json gs://<prefix>-care-patient-data</syntaxhighlight>
=== Configuring Google Kubernetes Engine (GKE) ===

==== Creating a GKE cluster ====

# Navigate to '''Kubernetes Engine''' > '''Clusters''' > '''Create'''.
# Choose '''Standard Mode'''.
# Configure cluster settings:
#* '''Name''': <code>care-gke</code>
#* '''Location''': <code>Zonal</code>
#* '''Zone''': <code>asia-south1-a</code>

==== Configuring node pools ====

# Select <code>default pool</code> and set nodes to <code>2</code>.
# In '''Nodes''' section:
#* '''Machine Type''': <code>E2-Series</code>, <code>e2-standard-2</code> (2 vCPU, 8 GB RAM)
# In '''Networking''' section:
#* '''Network''': <code>care-vpc</code>
#* '''Subnet''': <code>cluster-snet</code>
#* '''Access''': Public Cluster
# Enable '''HTTP Load Balancing'''.

== Build pipeline ==

=== Setting up the Artifact Registry ===

# Navigate to the '''Artifact Registry''' in the '''Google Cloud Console'''.
# Create private Artifact Registry repositories named <code>care</code> and <code>care_fe</code>.
# Ensure that the repositories are '''mutable'''.
# Use the '''Default Encryption Key''' for the repositories.

=== Setting up Cloud Source Repositories ===

# Navigate to the '''Cloud Source Repositories''' service in the '''Google Cloud Console'''.
# Create a new repository named <code>infra-name</code>.
# Add the files <code>build/react.env</code> and <code>plug_config.py</code> to the repository. (The <code>plug_config.py</code> file can be used to include plugins for <code>care</code>.)
# Add the following content to the <code>react.env</code> file:

<syntaxhighlight lang="yaml">REACT_PLAUSIBLE_SERVER_URL=https://plausible.example.com
REACT_HEADER_LOGO='{"light":"https://cdn.ohc.network/header_logo.png","dark":"https://cdn.ohc.network/header_logo.png"}'
REACT_MAIN_LOGO='{"light":"https://cdn.ohc.network/light-logo.svg","dark":"https://cdn.ohc.network/black-logo.svg"}'
REACT_GMAPS_API_KEY="examplekey"
REACT_GOV_DATA_API_KEY=""
REACT_RECAPTCHA_SITE_KEY=""
REACT_SENTRY_DSN=""
REACT_SAMPLE_FORMAT_ASSET_IMPORT=""
REACT_SAMPLE_FORMAT_EXTERNAL_RESULT_IMPORT=""
REACT_KASP_ENABLED=""
REACT_ENABLE_HCX=""
REACT_ENABLE_ABDM=""
REACT_ENABLE_SCRIBE=""
REACT_WARTIME_SHIFTING=""
REACT_OHCN_URL=""
REACT_PLAUSIBLE_SITE_DOMAIN="care.example.com"
REACT_SENTRY_ENVIRONMENT=""
REACT_CARE_API_URL="https://care.example.com"
REACT_DASHBOARD_URL=""</syntaxhighlight>
<ol start="5" style="list-style-type: decimal;">
<li>Add the following content to the <code>plug_config.py</code> file (if required):</li></ol>

<syntaxhighlight lang="python">from plugs.manager import PlugManager
from plugs.plug import Plug

hcx_plugin = Plug(
name="hcx",
package_name="git+https://github.com/ohcnetwork/care_hcx.git",
version="@main",
configs={},
)

plugs = [hcx_plugin]

manager = PlugManager(plugs)</syntaxhighlight>
<ol start="6" style="list-style-type: decimal;">
<li>Clone the [<nowiki/>https://github.com/ohcnetwork/infra_template infra_template] repository. This repository contains the necessary YAML files to deploy our applications as Kubernetes workloads. You will need to replace all generic/example values with your production values. Here's a guide on what to change in each folder:
<ul>
<li>'''Certificate''': Replace the example hostnames for <code>dnsNames</code> with your actual hostnames.</li>
<li>'''ConfigMaps''':
<ul>
<li>In <code>care-configmap.yaml</code>, add your database configurations.</li>
<li>Update the hostnames in <code>CSRF_TRUSTED_ORIGINS</code> and <code>DJANGO_ALLOWED_HOSTS</code>.</li>
<li>In <code>nginx.yaml</code>, update the <code>server_name</code> with your hostnames.</li></ul>
</li>
<li>'''Helm''':
<ul>
<li>Install Helm if you haven't already.</li>
<li>Use the static IP created from the '''"Reserve a static IP address"''' step to replace the IP value in <code>helm/scripts.sh</code>.</li></ul>
</li>
<li>'''Ingress''': Replace the example hostnames with your actual hostnames.</li>
<li>'''Secrets''':
<ul>
<li>Update <code>care-secrets.yml</code> with your secrets.</li>
<li>Update <code>metabase.yml</code> with your Metabase database credentials.</li></ul>
</li></ul>
</li>
<li>Push the changes to the <code>infra-name</code> repository created earlier in '''Cloud Source Repositories'''.</li></ol>

=== Setting up the Cloud Build project ===

# Navigate to the '''Cloud Build''' service in the '''Google Cloud Console'''.
# Establish a new build project, name it <code>deploy-care</code>.
# Generate a new trigger for the project.
# Configure the Event to respond to '''Webhook events'''.
# Retrieve the '''Webhook URL''' from the <code>Show URL Preview</code> option.
# Define the Configuration as <code>Cloud Build configuration file (yaml or json)</code>.
# Specify the Location as <code>Inline</code> and insert the following content:

<syntaxhighlight lang="yaml">steps:
- name: ubuntu
args:
- '-c'
- |
echo "be $_BE_TAG" \
&& echo "fe $_FE_TAG" \
&& echo "metabase $_METABASE_TAG"
entrypoint: bash

- name: 'gcr.io/google.com/cloudsdktool/cloud-sdk:slim'
args:
- '-c'
- |
gcloud source repos clone $_INFRA_REPO infra
cd infra
git config user.name "CloudBuild"
git config user.email example@cloudbuild.gserviceaccount.com
dir: /workspace
id: clone-infra
entrypoint: bash

- name: gcr.io/cloud-builders/gsutil
args:
- '-c'
- |
if [[ -n "$_BE_TAG" ]]; then
curl -L https://github.com/ohcnetwork/care/archive/$_BE_TAG.zip -o care.zip
unzip care.zip
mv care-$_BE_TAG care
else
echo "Skipping..."
fi
dir: /workspace
id: download-care
entrypoint: bash

- name: ubuntu
args:
- '-c'
- |
if [[ -n "$_BE_TAG" ]]; then
cp -r /workspace/infra/build/. /workspace/care
else
echo "Skipping..."
fi
id: copy-build-files
entrypoint: bash

- name: gcr.io/cloud-builders/docker
args:
- '-c'
- |
if [[ -n "$_BE_TAG" ]]; then
DOCKER_BUILDKIT=1 docker build -f ./care/docker/prod.Dockerfile \
-t asia-south1-docker.pkg.dev/$PROJECT_ID/care/care:$_BE_TAG \
-t asia-south1-docker.pkg.dev/$PROJECT_ID/care/care:latest \
./care
docker push \
asia-south1-docker.pkg.dev/$PROJECT_ID/care/care:$_BE_TAG
docker push \
asia-south1-docker.pkg.dev/$PROJECT_ID/care/care:latest
else
echo "Skipping..."
fi
dir: /workspace
id: build-care
entrypoint: bash

- name: gcr.io/cloud-builders/git
args:
- '-c'
- |
if [[ -n "$_BE_TAG" ]]; then
cd infra
sed -i -e 's|$image: .*care:$.*|\1$_BE_TAG|' deployments/*
sed -i -e "/name: deployment-version/{n;s/value: .*/value: \"$BUILD_ID\"/;}" deployments/care-backend.yaml
sed -i -e "/name: deployment-version/{n;s/value: .*/value: \"$BUILD_ID\"/;}" deployments/care-celery-worker.yaml
sed -i -e "/name: deployment-version/{n;s/value: .*/value: \"$BUILD_ID\"/;}" deployments/care-celery-beat.yaml
git add .
git commit -m "update backend crds to $_BE_TAG" || true
else
echo "Skipping..."
fi
dir: /workspace
id: update-care-crd
entrypoint: bash

- name: gcr.io/cloud-builders/gsutil
args:
- '-c'
- |
if [[ -n "$_FE_TAG" ]]; then
curl -L https://github.com/ohcnetwork/care_fe/archive/$_FE_TAG.zip -o /workspace/care_fe.zip
unzip /workspace/care_fe.zip -d /workspace
mv /workspace/care_fe-$_FE_TAG /workspace/care_fe
cp /workspace/infra/build/react.env /workspace/care_fe/.env.local
cd /workspace/care_fe
else
echo "Skipping..."
fi
dir: /workspace
id: download-care-fe
entrypoint: bash

- name: ubuntu
args:
- '-c'
- |
if [[ -n "$_FE_TAG" ]]; then
cp /workspace/infra/build/react.env /workspace/care_fe/.env.local
else
echo "Skipping..."
fi
id: copy-fe-build-files
entrypoint: bash

- name: gcr.io/cloud-builders/docker
args:
- '-c'
- |
if [[ -n "$_FE_TAG" ]]; then
DOCKER_BUILDKIT=1 docker build -f ./care_fe/Dockerfile \
-t asia-south1-docker.pkg.dev/$PROJECT_ID/care/care_fe:$_FE_TAG \
-t asia-south1-docker.pkg.dev/$PROJECT_ID/care/care_fe:latest \
./care_fe
docker push \
asia-south1-docker.pkg.dev/$PROJECT_ID/care/care_fe:$_FE_TAG
docker push \
asia-south1-docker.pkg.dev/$PROJECT_ID/care/care_fe:latest
else
echo "Skipping..."
fi
dir: /workspace
id: build-care-fe
entrypoint: bash

- name: gcr.io/cloud-builders/git
args:
- '-c'
- |
if [[ -n "$_FE_TAG" ]]; then
cd infra
sed -i -e 's|$image: .*care_fe:$.*|\1$_FE_TAG|' deployments/care-fe.yaml
sed -i -e "/name: deployment-version/{n;s/value: .*/value: \"$BUILD_ID\"/;}" deployments/care-fe.yaml
git add .
git commit -m "update frontend crds to $_FE_TAG" || true
else
echo "Skipping..."
fi
dir: /workspace
id: update-care-fe-crd
entrypoint: bash

- name: gcr.io/cloud-builders/git
args:
- '-c'
- |
if [[ -n "$_METABASE_TAG" ]]; then
cd infra
sed -i -e 's|$image: metabase/metabase:$.*|\1$_METABASE_TAG|' deployments/metabase.yaml
git add .
git commit -m "update frontend crds" || true
else
echo "Skipping..."
fi
dir: /workspace
id: update-metabase-crd
entrypoint: bash

- name: gcr.io/cloud-builders/gke-deploy
args:
- '-c'
- |
gke-deploy apply \
--location=${_CARE_GKE_ZONE} \
--cluster=${_CARE_GKE_CLUSTER} \
--filename=infra/deployments
dir: /workspace
id: deploy-to-gke
entrypoint: bash

- name: 'gcr.io/google.com/cloudsdktool/cloud-sdk:slim'
args:
- '-c'
- |
cd infra
git pull --rebase
git push
dir: /workspace
id: push-crds
entrypoint: bash

options:
logging: CLOUD_LOGGING_ONLY

substitutions:
_FE_TAG: $(body.substitutions.care_fe_tag)
_METABASE_TAG: $(body.substitutions.metabase_tag)
_BE_TAG: $(body.substitutions.care_be_tag)</syntaxhighlight>
<ol start="8" style="list-style-type: decimal;">
<li>Save the file and exit the editor.</li>
<li>Configure the '''Substitution variables''' for the Cloud Build trigger:
<ul>
<li>Navigate to the '''Substitution variables''' tab.</li>
<li>Select the <code>Add substitution variable</code> button.</li>
<li>Input the following variables:
<ul>
<li>Name: <code>_FE_TAG</code>, Value: ``</li>
<li>Name: <code>_METABASE_TAG</code>, Value: ``</li>
<li>Name: <code>_BE_TAG</code>, Value: ``</li>
<li>Name: <code>_CARE_GKE_ZONE</code>, Value: ``</li>
<li>Name: <code>_CARE_GKE_CLUSTER</code>, Value: ``</li>
<li>Name: <code>_INFRA_REPO</code>, Value: ``</li></ul>
</li>
<li>Save your changes.</li></ul>
</li>
<li>In a separate tab, create a '''Service Account''' for Cloud Build:
<ul>
<li>Navigate to the '''IAM Section'''.</li>
<li>Name the account <code>cloudbuilder</code>.</li>
<li>Assign the following roles:
<ul>
<li>Artifact Registry Administrator</li>
<li>Cloud Build Service Account</li>
<li>Cloud Run Source Developer</li>
<li>Cloud Source Repositories Service Agent</li>
<li>Kubernetes Engine Admin</li>
<li>Logs Bucket Writer</li>
<li>Secret Manager Secret Accessor</li>
<li>Source Repository Reader</li>
<li>Source Repository Writer</li></ul>
</li></ul>
</li>
<li>Assign the Service Account to the '''Cloud Build trigger''':
<ul>
<li>Navigate to the '''Service account''' tab.</li>
<li>Choose the <code>cloudbuilder</code> service account from the list.</li></ul>
</li>
<li>Save the trigger by selecting the <code>Create</code> button.</li></ol>

== Deploying ==

=== Getting ready for first deployment ===

==== Set the default GKE cluster ====

<syntaxhighlight lang="bash"># Get the name using:
kubectl config get-contexts

# Set the config:
kubectl config use-context <name></syntaxhighlight>
==== Run the Helm script ====

<syntaxhighlight lang="bash">bash helm/scripts.sh</syntaxhighlight>
==== Apply Kubernetes configurations ====

Use <code>kubectl</code> to apply all the Kubernetes YAML files in the following order:

<syntaxhighlight lang="bash"># Deploy ConfigMaps:
kubectl apply -f 'configmaps/*'

# Secrets:
kubectl apply -f 'secrets/*'

# Deployments:
kubectl apply -f 'deployments/*'

# Services:
kubectl apply -f 'services/*'

# ClusterIssuer:
kubectl apply -f ClusterIssuer/cluster-issuer.yaml

# Certificate:
kubectl apply -f certificate/certificate.yml

# Ingress:
kubectl apply -f ingress/care.yaml</syntaxhighlight>
Once ingress is created, <code>kubectl get ingress care-ingress</code> will show the IP of the TCP load balancer. Once the DNS records are added, the SSL will be automatically handled.

=== Add DNS records ===

Create DNS A records for each domain pointing to the static IP created from the "Reserve a static IP address" step.

=== Applying release updates on GCP manually ===

To apply release updates, follow these steps:

# Fetch the latest commit hash from the [<nowiki/>https://github.com/ohcnetwork/care/commits/production Care Commit History] and [<nowiki/>https://github.com/ohcnetwork/care_fe/commits/production Care FE Commit History].
# Trigger the Cloud Build using the webhook URL available in the Cloud Build console.
# Use <code>curl</code> or any API platform to initiate the build process:

<syntaxhighlight lang="bash">curl --request POST \
--url 'https://cloudbuild.googleapis.com/v1/projects/examplelink' \
--header 'Content-Type: application/json' \
--data '{
"substitutions": {
"care_be_tag": "",
"care_fe_tag": "",
"metabase_tag": ""
}
}'</syntaxhighlight>
=== Setting up automated GitHub workflow triggers ===

The manual process of triggering the build process can be automated using GitHub Actions. Follow these steps:

# Navigate to the deploy repository where the GitHub Actions are to be set up.
# Add the Webhook URL to the GitHub Secrets.
# Create a new GitHub Action workflow file in the <code>.github/workflows</code> directory.
# Add the following code snippet to the workflow file:

<syntaxhighlight lang="yaml">name: Deploy Multiple Projects
on:
workflow_dispatch:
inputs:
BE_TAG:
description: "Backend release tag"
required: true
FE_TAG:
description: "Frontend release tag"
required: true
METABASE_TAG:
description: "Metabase release tag"
required: false

jobs:
trigger-post-requests:
runs-on: ubuntu-latest
steps:
- name: Setup Payload
run: |
JSON='{ "substitutions": { "care_be_tag":"'"$BE_TAG"'", "care_fe_tag": "'"$FE_TAG"'", "metabase_tag": "'"$METABASE_TAG"'" } }'
echo "json=$JSON" >> $GITHUB_ENV
env:
BE_TAG: ${{ github.event.inputs.BE_TAG }}
FE_TAG: ${{ github.event.inputs.FE_TAG }}
METABASE_TAG: ${{ github.event.inputs.METABASE_TAG }}
- name: Deploy Project 1
env:
SECRET_URL: ${{ secrets.WEBHOOK_P1 }}
run: |
curl -X POST -H "Content-Type: application/json" \
-d "$json" \
$SECRET_URL

- name: Deploy Project 2
env:
SECRET_URL: ${{ secrets.WEBHOOK_P2 }}
run: |
curl -X POST -H "Content-Type: application/json" \
-d "$json" \
$SECRET_URL

- name: Deploy Project 3
env:
SECRET_URL: ${{ secrets.WEBHOOK_P3 }}
run: |
curl -X POST -H "Content-Type: application/json" \
-d "$json" \
$SECRET_URL

- name: Deploy Project 4
env:
SECRET_URL: ${{ secrets.WEBHOOK_P4 }}
run: |
curl -X POST -H "Content-Type: application/json" \
-d "$json" \
$SECRET_URL

- name: Deploy Project 5
env:
SECRET_URL: ${{ secrets.WEBHOOK_P5 }}
run: |
curl -X POST -H "Content-Type: application/json" \
-d "$json" \
$SECRET_URL

- name: Deploy Project 6
env:
SECRET_URL: ${{ secrets.WEBHOOK_P6 }}
run: |
curl -X POST -H "Content-Type: application/json" \
-d "$json" \
$SECRET_URL</syntaxhighlight>
=== Applying release updates ===

To apply release updates, follow these steps:

# Retrieve the latest commit hash from the [<nowiki/>https://github.com/ohcnetwork/care/commits/production Care Commit History] and [<nowiki/>https://github.com/ohcnetwork/care_fe/commits/production Care FE Commit History].
# Go to the deploy repository where the GitHub Action mentioned above is set up.
# Click on the <code>Actions</code> tab.
# Choose the <code>Deploy Multiple Projects</code> workflow.
# Click on the <code>Run Workflow</code> button.
# Input the latest commit hash for both the backend and frontend.
# Click on the <code>Run Workflow</code> button again.

These steps will initiate the build pipeline for the backend and frontend projects across all the projects set up in the GitHub Secrets.

{{Related}}

Deployment/Providers/Gcp/Deploying Care on GKE - Revision history

Admin: Add Navbox deployment template before Related (via update-page on MediaWiki MCP Server)

Admin: OHC identity seed