Deploy DPA on the Kubernetes Cloud Platform

For a list of platforms that DPA can run on, see Install or deploy DPA.

Complete the following tasks to deploy DPA in a container on the Kubernetes Cloud Platform:

• Create the AWS infrastructure for deploying a DPA container
• Create a role for the Elastic File System driver
• Create the Elastic File System
• Create CSI-controller pods
• Create a stand-alone machine and push the DPA Docker container image to the AWS Elastic Container Registry
• Create the DPA deployment in the AWS Elastic Kubernetes Service
• Access DPA

Create the AWS infrastructure for deploying a DPA container

1. Log in to the AWS Console.

2. Create an Elastic Container Registry (ECR).

   The ECR will hold the DPA container images. Note the URI of the ECR, which will be required in later steps.

3. Create the two IAM roles that will be required for the Kubernetes cluster creation process.

   1. Create the first role, which is a cluster role:

      • Specify the following options:

        • Trusted entity type: AWS service
        • Use case: EKS
        • Use case for the service: EKS - Auto Cluster

      • Assign the following permissions:

        • AmazonEKSBlockStoragePolicy
        • AmazonEKSClusterPolicy
        • AmazonEKSComputePolicy
        • AmazonEKSLoadBalancingPolicy
        • AmazonEKSNetworkingPolicy

      • Assign a role name (for example, dpaclusterrole).

   2. Create the second role, which is a node role:

      • Specify the following options:

        • Trusted entity type: AWS service
        • Use case: EKS
        • Use case for the service: EKS - Auto Node

      • Assign the following permissions:

        • AmazonEC2ContainerRegistryPullOnly
        • AmazonEKSWorkerNodeMinimalPolicy
        • AmazonEFSCSIDriverPolicy
        • AmazonEKS_CNI_Policy
        • AmazonEKSWorkerNodePolicy

        If necessary, you can edit the permissions and add others after the role is created.

      • Assign a role name (for example, dpanoderole).

4. Create an Elastic Kubernetes Service (EKS) cluster.

   You can create the cluster using either the Quick configuration option or the Custom configuration option. Select the following options.

   Make sure that ECR and EKS are both in the same region (for example, us-west-2).

   • For the Cluster IAM role, select the cluster role you created in step 2.

   • For the Node IAM role, select the node role you created in step 2.

   • If you chose the Custom configuration option, include the Amazon EFS CSI Drive Add-on.

5. Create an OpenID Connect (OIDC) provider for the cluster created in the previous step.

   This provider will be used for role creation in the following section.

   1. Get the EKS cluster’s OIDC issuer URL.

      For example, from the Amazon Elastic Kubernetes Service page in the AWS portal. Select Clusters, and click your cluster name. In the Details section, copy the OpenID Connect provider URL. It should look something like:

      https://oidc.eks.us-west-2.amazonaws.com/id/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

   2. Add the OIDC provider in IAM.

      For example, from the IAM Dashboard in the AWL portal, select identity providers, and click Add provider.

      Specify the following information:

      • Provider type: OpenID Connect
      • Provider URL: The OIDC URL copied in step 5a.
      • Audience: sts.amazonaws.com

Create a role for the Elastic File System driver

Create a role for the Elastic File System (EFS) driver, which will be used by the persistent volume to store DPA configuration files. When you create the role:

• Specify the following options:

  • Trusted entity type: Web identity
  • Identity provider: The OIDC provider created in the previous steps
  • Audience: sts.amazonaws.com

• Assign the following permission:

  • AmazonEFSCSIDriverPolicy

• Assign a role name (for example, dpaefsdriverrole).

Create the Elastic File System

Create an Elastic File System (EFS) in AWS that will be used to store DPA configuration files and the persistent volume that DPA needs to store the configuration files.

When you are creating the EFS, use the same VPC network that you used when you created the EKS. You can specify any name for the EFS.

After the EFS has been created, make a note of the File system ID. This ID will be required later.

Create CSI-controller pods

When an EKS cluster is created, by default the CSI-driver pods are not present in the cluster. CSI-driver pods are required to write data into the file system. To install these pods, perform the following steps:

1. Open Cloudshell, the AWS cloud command prompt.

2. Log in to the EKS you created earlier. An example of a command to do this is:

   aws eks update-kubeconfig --region EKS_REGION --name EKS_NAME

3. Create the CSI-controller pods:

   kubectl apply -k "http://github.com/kubernetes-sigs/aws-efs-csi-driver/deploy/kubernetes/overlays/stable/ecr/?ref=release-1.7 "

4. Link the CSI driver pods to the role (dpadriverrole) created earlier. Replace AWS_ACCOUNT_ID with the appropriate account ID.

   kubectl annotate serviceaccount efs-csi-controller-sa -n kube-system eks.amazonaws.com/role-arn=arn:aws:iam::AWS_ACCOUNT_ID:role/dpadriverrole --overwrite

5. Restart the CSI driver pods:

   kubectl -n kube-system delete pod -l app=efs-csi-controller

The infrastructure required to create a DPA container in AWS EKS is prepared.

Create a stand-alone machine and push the DPA Docker container image to the AWS Elastic Container Registry

In addition to the AWS infrastructure created in the previous sections, you must create a stand-alone machine where Docker can be installed (for example, a Centos, Ubuntu, or Windows VM and Docker). You will use this machine to download the tar.gz file of the DPA Docker container image, then and upload it to the AWS Elastic Container Registry.

Download the required files

When this machine is ready, download the required files:

1. Open the link provided to you by a SolarWinds representative.

2. Download the following files:

   • The tar.gz file that holds the DPA Docker container image. The file name is similar to the following, where nnnn.n.n.n represents the version number:

     SolarWinds-DPA-Image-nnnn.n.n.n.tar.gz

   • The four sample .yaml files.

Upload the container image

Complete the following steps to upload the DPA Docker container image to the AWS Elastic Container Registry:

1. Run the following command to load the image from the tar.gz file:

   docker load < FILENAME

   For example:

   docker load < SolarWinds-DPA-Image-2025.4.0.512.tar.gz

2. After you run the docker load command, verify that the image is loaded by running the command to list Docker images:

   docker images

   The list of images should include solarwinds/dpa.

3. Log in to the AWS Elastic Container Registry and use the AWS and Docker login command to push the image. Use the URI of the ECR created in a previous section. For example:

   aws ecr get-login-password --region AWS_REGION | docker login --username AWS--password-stdin AWS_ECR_URI

4. Push the Docker image to the AWS Elastic Container Registry:

   docker push IMAGE_NAME:TAG

   For example:

   docker push solarwinds/dpa:2025.4.0.512

Create the DPA deployment in the AWS Elastic Kubernetes Service

When the AWS Elastic Kubernetes Service created earlier is up, use the .yaml files to create the DPA container.

The .yaml files that you downloaded in the previous task are samples to help you get started quickly. You can edit them as needed for your environment.

1. Run the following command to create the persistent volume on the cloud platform:

   kubectl apply -f dpa_pv_aws.yaml

2. Run the following command to create the persistent volume claim (PVC) to store the DPA configuration folders (for example, ignite_config, tomcat-conf, logs, and licensing). The persistent volume you created earlier is used to create the PVC.

   kubectl apply -f dpa_pvc_aws.yaml

3. Create the DPA pod:

   1. Open the dpa_pod_aws.yaml file in a text editor, and update the image property to the correct value:

      AWS_ECR_URL/RepoName:VersionNumber

      For example:

      xxxxxxxxxx.dkr.ecr.us-west-2.amazonaws.com/solarwinds/dpa:2025.4.0.512

      The dpa_pod_aws.yaml file includes information such as the port, version of the image, CPU limit, memory limit, and name of PVC created earlier.

   2. Run the following command to create the DPA pod:

      kubectl apply -f dpa_pod_aws.yaml

4. If the container needs to be accessed from a public network, then assign public IP/FQDN to the container. Also, before you create this load balancer service, annotate all the subnets of the VPC of EKS with the following tags:

   • Tag 1

     • Key: kubernetes.io/role/elb
     • Value: 1

   • Tag 2

     • Key: kubernetes.io/cluster/your-cluster-name
     • Value: shared

5. To expose the external IP address for the DPA pod, run the following command to create the external load balancer service:

   kubectl apply -f dpa_lb_aws.yaml

Access DPA

After you complete the previous steps, you can access DPA through the browser using the PUBLIC_FQDN provided in the dpa_lb_aws.yaml file. You can check the public IP address through the AWS Console by doing the following:

1. Open the Elastic Kubernetes Service page and click Clusters.

2. Click the name of the cluster you created.

3. Click the Resources tab.

4. Under Resource types, click Service and networking > Services.

5. Click the dpacontainer service name.

The DPA URL is:

https://PUBLIC_FQDN:443/

After you access DPA, create the repository database.