Procedure

1. 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

   Following is the specified locations in the manifests:

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

2. Apply the modified Operator manifest to your Kubernetes cluster:

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

   Note

   Execution of the previous command is cluster-scoped and requires appropriate cluster privileges.

3. 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>

4. 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

5. To deploy the created Ingress, run the following command:

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

6. 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:
           externalAccess:
               - type: legacy
                 options:
                   subject: legacy-default-config
                   secret: "${BACKEND_SECRET}"
         baseUrl: https://<app_address>
         cors:
           origin: https://<app_address>

7. 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"

8. 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"

9. Apply the CR manifest to your namespace:

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

10. 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).

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

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

Procedure

1. Log in to AKS by running the following command:

   az login [--tenant=<optional_directory_name>]

2. Create a resource group by running the following command:

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

   Tip

   You can list available regions by running the following command:

   az account list-locations -o table

3. 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

   You can refer to --help for additional options.

4. Connect to your cluster by running the following command:

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

   The previous command configures the Kubernetes client and sets the current context in the kubeconfig to point to your AKS cluster.

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

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

6. Create and activate the <rhdh> namespace:

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

7. 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>

8. 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

9. 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.4.0

10. Verify the deployment status:

    kubectl get deploy $DEPLOYMENT_NAME -n $NAMESPACE

11. 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.4.0/redhat-developer-hub-1.4.0.tgz" \
        --set global.clusterRouterBase="$CLUSTER_ROUTER_BASE" \
        --set global.postgresql.auth.password="$PASSWORD"

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

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