My first experience with ACE, OpenShift & ArgoCD

I had the possibility to do an internship at Integration Designers during the final year of my IT studies. The topic was to investigate how easily one could move App Connect Enterprise applications from a local openshift cluster to a cluster managed in the cloud. Technologies I was required to use were IBM app connect enterprise, OpenShift , ArgoCD and gitlab.

Having no background on these subjects, I still managed to put all this together with the help of my coworkers who have done an incredible job showing me the ropes and helping me look for solutions to my problems.

Course of action

To properly execute what I will be explaining below, we created a course of action which would ensure that there would be constant progress and a learning curve that would not be too steep or flat.

We worked in an agile way where I would gradually take in more information on what the eventual POC would be.

I began with learning the basics of IBM App Connect Enterprise.

Next is understanding OpenShift and deploying an artefact of my application with the ACE operator.

Followed by deploying an ACE application with ArgoCD which would automate the deployment and update the application when changes are committed to our code repository.

My ACE Application

As the deployed application itself is not the main focus of my internship task, I did not create a complex example. What we see here is a straightforward “hello world” where if I send a message, the application will send it back to me. The purpose is not the application but the deployable artefact of the application.

OpenShift

My experience with OpenShift has been very pleasant as it is very user-friendly with a lot of tools to help you create instances in a heartbeat. Having no knowledge of the platform I learned some things on my own but got a speed course to make sure I understand what is happening in the background and how to do the same things through command line. However, since OpenShift is made to be used, I worked mainly through the UI and found it to be fairly easy to learn and understand.

The example below shows you that everything is nicely sorted, that OpenShift easy to navigate through and that everything is easily accessible.

We are using OpenShift to deploy our app connect enterprise application using the ACE operator.

The first step was deploying the artifact using the operator.

To make sure that our application would be deployed properly, I had to create some configuration files that would be used to properly set up the UI that allows us to access our deployed application.

You can either do it with the OpenShift console or through the Command line tool “oc”.

Everything I did and created is documented, which also means that the files needed to create and deploy the application is easy to find and use.

Through your command line you can simply tell OpenShift to “apply” a file and it will create it by itself.

ArgoCD

ArgoCD is the tool that I use for continuous deployment. After setting it up, it is a very straightforward process on how to link your git repository and navigating ArgoCD to the right files that should be deployed.

No added tasks or building tools to set up. Just link your ArgoCD to the repository and it will take all the hustle and work off of your hands.

Same as my tinkering with OpenShift, everything I’ve done is documented to make sure that there is a simple and understandable step by step tutorial to create similar projects.

We found a yaml file that, after some altering, allowed us to create an ArgoCD artifact with all needed configurations and dependencies.

Afterwards it was just a matter of linking the repository, which is structured properly, and ArgoCD would find it’s way through the files to create the right application with it’s configurations.

And as you can see below, ArgoCD understands the files that are within your repo and consults the right operators to deploy the right instances within our OpenShift cluster. And since ArgoCD monitors our cluster and checks our repository for changes, your applications will be up to date at all times with logs that explain problems from both sides.

Below you can a schematic representation on how the gitrepo is structured.

Folder: blue

File: green

Within the “Application” folder you can see a file “Customization”, within this file we find definitions on what files to use, where to get them and in what order to create them. As you can see below ArgoCD will use these yaml files to create instances of what is configured within these files. In the bottom left of each deployment, you will see it’s type of instance. (config, secret, …)

Conclusion

After some digging around on each of these subjects, I find that the concepts are really easy to understand. The steps to follow are simple but you do have to know them. To help my colleagues I have created tutorials on how to create the things that I have described in this blog.

I have enjoyed learning these concepts and hope that what I have created and documented will help my colleagues in the future.