Argo CD applications

Procedure

1. In the Argo CD dashboard, click NEW APP to add a new Argo CD application.

2. For this workflow, create a spring-petclinic application with the following configurations:

   Application Name

   spring-petclinic

   Project

   default

   Sync Policy

   Automatic

   Repository URL

   https://github.com/redhat-developer/openshift-gitops-getting-started

   Revision

   HEAD

   Path

   app

   Destination

   https://kubernetes.default.svc

   Namespace

   spring-petclinic

3. Click CREATE to create your application.
4. Open the Administrator perspective of the web console and expand Administration → Namespaces.
5. Search for and select the namespace, then enter argocd.argoproj.io/managed-by=openshift-gitops in the Label field so that the Argo CD instance in the openshift-gitops namespace can manage your namespace.

Procedure

1. Download the sample application:

   $ git clone git@github.com:redhat-developer/openshift-gitops-getting-started.git

2. Create the application:

   $ oc create -f openshift-gitops-getting-started/argo/app.yaml

3. Run the oc get command to review the created application:

   $ oc get application -n openshift-gitops

4. Add a label to the namespace your application is deployed in so that the Argo CD instance in the openshift-gitops namespace can manage it:

   $ oc label namespace spring-petclinic argocd.argoproj.io/managed-by=openshift-gitops

Procedure

1. In the Argo CD dashboard, verify that your application has the Synced status.
2. Click the app-spring-petclinic tile in the Argo CD dashboard to view the application resources that are deployed to the cluster.
3. In the OpenShift Container Platform web console, navigate to the Developer perspective.

4. Modify the Spring PetClinic deployment and commit the changes to the app/ directory of the Git repository. Argo CD will automatically deploy the changes to the cluster.

   1. Fork the OpenShift GitOps getting started repository.
   2. In the deployment.yaml file, change the failureThreshold value to 5.

   3. In the deployment cluster, run the following command to verify the changed value of the failureThreshold field:

      $ oc edit deployment spring-petclinic -n spring-petclinic

5. Test the self-healing behavior by modifying the deployment on the cluster and scaling it up to two pods while watching the application in the OpenShift Container Platform web console.

   1. Run the following command to modify the deployment:

      $ oc scale deployment spring-petclinic --replicas 2  -n spring-petclinic

   2. In the OpenShift Container Platform web console, notice that the deployment scales up to two pods and immediately scales down again to one pod. Argo CD detected a difference from the Git repository and auto-healed the application on the OpenShift Container Platform cluster.
6. In the Argo CD dashboard, click the app-spring-petclinic tile → APP DETAILS → EVENTS. The EVENTS tab displays the following events: Argo CD detecting out of sync deployment resources on the cluster and then resyncing the Git repository to correct it.

Procedure

1. Get the admin account password for the Argo CD server:

   $ ADMIN_PASSWD=$(oc get secret openshift-gitops-cluster -n openshift-gitops -o jsonpath='{.data.admin\.password}' | base64 -d)

2. Get the Argo CD server URL:

   $ SERVER_URL=$(oc get routes openshift-gitops-server -n openshift-gitops -o jsonpath='{.status.ingress[0].host}')

3. Log in to the Argo CD server by using the admin account password and enclosing it in single quotes:

   Important

   Enclosing the password in single quotes ensures that special characters, such as $, are not misinterpreted by the shell. Always use single quotes to enclose the literal value of the password.

   $ argocd login --username admin --password ${ADMIN_PASSWD} ${SERVER_URL}

   Example:

   $ argocd login --username admin --password '<password>' openshift-gitops.openshift-gitops.apps-crc.testing

4. Verify that you are able to run argocd commands in the default mode by listing all applications:

   $ argocd app list

   If the configuration is correct, then existing applications will be listed with the following header:

   Sample output:

   NAME CLUSTER NAMESPACE  PROJECT  STATUS  HEALTH   SYNCPOLICY  CONDITIONS  REPO PATH TARGET

5. Create an application in the default mode:

   $ argocd app create app-spring-petclinic \
       --repo https://github.com/redhat-developer/openshift-gitops-getting-started.git \
       --path app \
       --revision main \
       --dest-server  https://kubernetes.default.svc \
       --dest-namespace spring-petclinic \
       --directory-recurse \
       --sync-policy automated \
       --self-heal \
       --sync-option Prune=true \
       --sync-option CreateNamespace=true

6. Label the spring-petclinic destination namespace to be managed by the openshif-gitops Argo CD instance:

   $ oc label ns spring-petclinic "argocd.argoproj.io/managed-by=openshift-gitops"

7. List the available applications to confirm that the application is created successfully and repeat the command until the application has the Healthy and Synced statuses:

   $ argocd app list

Procedure

1. Log in to the OpenShift Container Platform cluster by using the oc CLI tool:

   $ oc login -u <username> -p <password> <server_url>

   Example:

   $ oc login -u kubeadmin -p '<password>' https://api.crc.testing:6443

2. Check whether the context is set correctly in the kubeconfig file:

   $ oc config current-context

3. Set the default namespace of the current context to openshift-gitops:

   $ oc config set-context --current --namespace openshift-gitops

4. Set the following environment variable to override the Argo CD component names:

   $ export ARGOCD_REPO_SERVER_NAME=openshift-gitops-repo-server

5. Verify that you are able to run argocd commands in core mode by listing all applications:

   $ argocd app list --core

   If the configuration is correct, then existing applications will be listed with the following header:

   Sample output:

   NAME CLUSTER NAMESPACE  PROJECT  STATUS  HEALTH   SYNCPOLICY  CONDITIONS  REPO PATH TARGET

6. Create an application in core mode:

   $ argocd app create app-spring-petclinic --core \
       --repo https://github.com/redhat-developer/openshift-gitops-getting-started.git \
       --path app \
       --revision main \
       --dest-server  https://kubernetes.default.svc \
       --dest-namespace spring-petclinic \
       --directory-recurse \
       --sync-policy automated \
       --self-heal \
       --sync-option Prune=true \
       --sync-option CreateNamespace=true

7. Label the spring-petclinic destination namespace to be managed by the openshif-gitops Argo CD instance:

   $ oc label ns spring-petclinic "argocd.argoproj.io/managed-by=openshift-gitops"

8. List the available applications to confirm that the application is created successfully and repeat the command until the application has the Healthy and Synced statuses:

   $ argocd app list --core

Procedure

1. In the Administrator perspective of the web console, click Operators → Installed Operators.
2. From the Project list, select the project where the user-defined cluster-scoped Argo CD instance is installed.
3. Select Red Hat OpenShift GitOps from the installed Operators list and go to the Argo CD tab.
4. Click your user-defined cluster-scoped Argo CD instance.

5. Configure the ArgoCD CR of your user-defined cluster-scoped Argo CD instance with the target namespaces:

   1. Click the YAML tab and edit the YAML file of the ArgoCD CR.

   2. In the ArgoCD CR, set the value of the sourceNamespaces parameter to include the non-control plane namespaces:

      Example ArgoCD CR:

      apiVersion: argoproj.io/v1beta1
      kind: ArgoCD
      metadata:
        name: example
        namespace: spring-petclinic
      spec:
        sourceNamespaces:
          - dev
          - app-team-*

      where:

      metadata.name

      Specifies the name of the user-defined cluster-scoped Argo CD instance.

      metadata.namespace

      Specifies the namespace where the user-defined cluster-scoped Argo CD instance is created.

      spec.sourceNamespaces

      Specifies the namespaces where users can create and manage Application resources handled by the Argo CD instance. You can use wildcard patterns (*), to allow the Argo CD instance to manage Application resources in matching namespaces like app-team-1 or app-team-2.

   3. Click Save and Reload.

      Note

      When a target namespace is specified under the sourceNamespaces field, the Operator adds the argocd.argoproj.io/managed-by-cluster-argocd label to the specified namespace.

      Example dev target namespace:

      apiVersion: v1
      kind: Namespace
      metadata:
        name: dev
        labels:
          argocd.argoproj.io/managed-by-cluster-argocd: spring-petclinic
          kubernetes.io/metadata.name: dev

      where:

      metadata.name

      Specifies the namespace of the user-defined cluster-scoped Argo CD instance.

      spec.sourceRepos or spec.destinations (Application)

      the target namespace for the Argo CD server to create and manage Application resources.

6. Verify that Operator adds the argocd.argoproj.io/managed-by-cluster-argocd label to the specified namespace:

   1. Go to Administration → Namespaces and click Create Namespace.

   2. In the Create Namespace dialog box, provide the Name and click Create.

      For example, to create dev target namespace, enter dev in the Name field. You can repeat the previous steps to create the app-team-1 and app-team-2 target namespaces.

      The Namespaces page displays the created target namespaces.

   3. Click the target namespace and go to the YAML tab to verify the argocd.argoproj.io/managed-by-cluster-argocd label added by the Operator.

Verification

1. Verify that your user-defined cluster-scoped Argo CD instance is configured with a cluster role to manage cluster-scoped resources:

   1. Go to User Management → Roles and from the Filter list, select Cluster-wide Roles.

   2. Search for the created cluster roles by using the Search by name field. For example, example-spring-petclinic-argocd-application-controller and example-spring-petclinic-argocd-server.

      The Roles page displays the created cluster roles.

   3. Verify that the following role-based access control (RBAC) resources are created by the GitOps Operator:

      Expand

      Name	Kind	Purpose
      <argocd_name>-<argocd_namespace>-argocd-application-controller	ClusterRole and ClusterRoleBinding	For the Argo CD Application Controller to watch and list Application resources at cluster-level
      <argocd_name>-<argocd_namespace>-argocd-server	ClusterRole and ClusterRoleBinding	For the Argo CD Server to watch and list Application resources at cluster-level
      <argocd_name>-<target_namespace>	Role and RoleBinding	For the Argo CD server to manage Application resources in target namespace through the UI, API, or CLI

      Show more

Procedure

1. Create and configure a user-defined AppProject instance in the openshift-gitops control plane namespace to specify the target namespaces in the .spec.sourceNamespaces field:

   1. From the Project list, select the openshift-gitops project.
   2. In the Administrator perspective of the web console, click Operators → Installed Operators → Red Hat OpenShift GitOps and go to the AppProject tab.

   3. Click Create AppProject and enter the following configuration in the YAML view:

      Example user-defined AppProject instance:

1. Click Create.

   The AppProjects page displays the created user-defined AppProject instance.

Procedure

1. Create and configure the Application CR with the parameters for the metadata.namespace and .spec.project fields to reference the target namespace and user-defined AppProject instance:

   1. From the Project list, select the target namespace.
   2. In the Administrator perspective of the web console, click Operators → Installed Operators → Red Hat OpenShift GitOps and go to the Application tab.

   3. Click Create Application and enter the following configuration in the YAML view:

      Example user-defined AppProject instance:

      kind: Application
      apiVersion: argoproj.io/v1alpha1
      metadata:
        name: cluster-configs
        namespace: dev
      spec:
        project: project-one
        # ...

      +

      where:

      metadata.name

      Specifies the name of the application.

      spec.project (Application)

      the name of the target namespace for the Argo CD server to create and manage Application resources.

      spec.project (AppProject)

      the name of the user-defined AppProject instance.

1. Click Create.

Procedure

1. Create a parent Application in the primary Argo CD instance:

   apiVersion: argoproj.io/v1alpha1
   kind: Application
   metadata:
     name: parent-app
     namespace: argocd
   spec:
     project: default
     source:
       repoURL: https://github.com/YOUR-ORG/my-apps-repo.git
       targetRevision: main
       path: path-to-child-app
     destination:
       server: https://kubernetes.default.svc
       namespace: namespace-b
     syncPolicy:
       automated:
         selfHeal: true
         prune: true

   The parent Application deploys child Applications from the specified repository.

2. Add the managed-by-url annotation to the child Application definition in your Git repository. Replace https://secondary-argocd.example.com with the actual URL of your secondary Argo CD instance:

   apiVersion: argoproj.io/v1alpha1
   kind: Application
   metadata:
     name: child-app
     namespace: namespace-b
     annotations:
       argocd.argoproj.io/managed-by-url: "https://secondary-argocd.example.com"
   spec:
     project: default
     source:
       repoURL: https://github.com/YOUR-ORG/my-apps-repo.git
       targetRevision: main
       path: path-to-child-app
     destination:
       server: https://kubernetes.default.svc
       namespace: namespace-b
     syncPolicy:
       automated:
         selfHeal: true
         prune: true

   The annotation defines the Argo CD instance that manages the child Application.

3. Apply or sync the parent Application.

Verification

1. Log in to the primary Argo CD instance.
2. Navigate to the parent-app Application.
3. Select the child-app resource from the resource tree.
4. Verify that the link opens in the correct Argo CD instance at the URL specified in the annotation.

1. The child Application YAML in Git includes the annotation.
2. The parent Application synced successfully.
3. The child Application exists in the cluster.