Installing Red Hat Developer Hub on Microsoft Azure Kubernetes Service

Obtain the Red Hat Developer Hub Operator manifest file, named rhdh-operator-<VERSION>.yaml, and modify the default configuration of db-statefulset.yaml and deployment.yaml by adding the following fragment:

securityContext:
  fsGroup: 300

db-statefulset.yaml: | spec.template.spec
deployment.yaml: | spec.template.spec

Apply the modified Operator manifest to your Kubernetes cluster:

kubectl apply -f rhdh-operator-<VERSION>.yaml

Create an ImagePull Secret named rhdh-pull-secret using your Red Hat credentials to access images from the protected registry.redhat.io as shown in the following example:

kubectl -n <your_namespace> create secret docker-registry rhdh-pull-secret \
    --docker-server=registry.redhat.io \
    --docker-username=<redhat_user_name> \
    --docker-password=<redhat_password> \
    --docker-email=<email>

Create an Ingress manifest file, named rhdh-ingress.yaml, specifying your Developer Hub service name as follows:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: rhdh-ingress
  namespace: <your_namespace>
spec:
  ingressClassName: webapprouting.kubernetes.azure.com
  rules:
    - http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: backstage-<your-CR-name>
                port:
                  name: http-backend

To deploy the created Ingress, run the following command:

kubectl -n <your_namespace> apply -f rhdh-ingress.yaml

Create a ConfigMap named app-config-rhdh containing the Developer Hub configuration using the following example:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config-rhdh
data:
  "app-config-rhdh.yaml": |
    app:
      title: Red Hat Developer Hub
      baseUrl: https://<app_address>
    backend:
      auth:
        keys:
          - secret: "${BACKEND_SECRET}"
      baseUrl: https://<app_address>
      cors:
        origin: https://<app_address>

Create a Secret named secrets-rhdh and add a key named BACKEND_SECRET with a Base64-encoded string value as shown in the following example:

apiVersion: v1
kind: Secret
metadata:
  name: secrets-rhdh
stringData:
  BACKEND_SECRET: "xxx"

Create a Custom Resource (CR) manifest file named rhdh.yaml and include the previously created rhdh-pull-secret as follows:

apiVersion: rhdh.redhat.com/v1alpha1
kind: Backstage
metadata:
  name: <your-rhdh-cr>
spec:
  application:
    imagePullSecrets:
      - rhdh-pull-secret
    appConfig:
      configMaps:
        - name: "app-config-rhdh"
    extraEnvs:
      secrets:
        - name: "secrets-rhdh"

Apply the CR manifest to your namespace:

kubectl -n <your_namespace> apply -f rhdh.yaml

Access the deployed Developer Hub using the URL: https://<app_address>;, where <app_address> is the Ingress address obtained earlier (for example, https://108.141.70.228).

Optional: To delete the CR, run the following command:

kubectl -n <your_namespace> delete -f rhdh.yaml

Log in to AKS by running the following command:

az login [--tenant=<optional_directory_name>]

Create a resource group by running the following command:

az group create --name <resource_group_name> --location <location>

az account list-locations -o table

Create an AKS cluster by running the following command:

az aks create \
--resource-group <resource_group_name> \
--name <cluster_name> \
--enable-managed-identity \
--generate-ssh-keys

Connect to your cluster by running the following command:

az aks get-credentials --resource-group <resource_group_name> --name <cluster_name>

Open terminal and run the following command to add the Helm chart repository:

helm repo add openshift-helm-charts https://charts.openshift.io/

Create and activate the <rhdh> namespace:

DEPLOYMENT_NAME=<redhat-developer-hub>
NAMESPACE=<rhdh>
kubectl create namespace ${NAMESPACE}
kubectl config set-context --current --namespace=${NAMESPACE}

Create a pull secret, which is used to pull the Developer Hub images from the Red Hat Ecosystem, by running the following command:

kubectl -n $NAMESPACE create secret docker-registry rhdh-pull-secret \
    --docker-server=registry.redhat.io \
    --docker-username=<redhat_user_name> \
    --docker-password=<redhat_password> \
    --docker-email=<email>

Create a file named values.yaml using the following template:

global:
  host: <app_address>
route:
  enabled: false
upstream:
  ingress:
    enabled: true
    className: webapprouting.kubernetes.azure.com
    host:
  backstage:
    image:
      pullSecrets:
        - rhdh-pull-secret
    podSecurityContext:
      fsGroup: 3000
  postgresql:
    image:
      pullSecrets:
        - rhdh-pull-secret
    primary:
      podSecurityContext:
        enabled: true
        fsGroup: 3000
  volumePermissions:
    enabled: true

To install Developer Hub by using the Helm chart, run the following command:

helm -n $NAMESPACE install -f values.yaml $DEPLOYMENT_NAME openshift-helm-charts/redhat-developer-hub --version 1.3.0

Verify the deployment status:

kubectl get deploy $DEPLOYMENT_NAME -n $NAMESPACE

Configure your Developer Hub Helm chart instance with the Developer Hub database password and router base URL values from your cluster:

PASSWORD=$(kubectl get secret redhat-developer-hub-postgresql -o jsonpath="{.data.password}" | base64 -d)
CLUSTER_ROUTER_BASE=$(kubectl get route console -n openshift-console -o=jsonpath='{.spec.host}' | sed 's/^[^.]*\.//')
helm upgrade $DEPLOYMENT_NAME -i "https://github.com/openshift-helm-charts/charts/releases/download/redhat-redhat-developer-hub-1.3.0/redhat-developer-hub-1.3.0.tgz" \
    --set global.clusterRouterBase="$CLUSTER_ROUTER_BASE" \
    --set global.postgresql.auth.password="$PASSWORD"

Display the running Developer Hub instance URL, by running the following command:

echo "https://$DEPLOYMENT_NAME-$NAMESPACE.$CLUSTER_ROUTER_BASE"