Guide to starting use AWX on top of OpenShift, the upstream of Red Hat Ansible Tower


This is the first post in a series that shows how to use the new release of the community version of Red Hat Ansible Tower. In this post, we will start with the installation of AWX on top of OpenShift. In the next post, I’ll show how to set a dynamic inventory to access the servers from AWS (EC2) and how to run a playbook to access our AWS EC2 inventory.

Continue reading “Guide to starting use AWX on top of OpenShift, the upstream of Red Hat Ansible Tower”


Running a NuGet server on OpenShift

When you build your .NET Core project, NuGet packages are retrieved from by default. Sometimes, however, you might want to use a local NuGet repository. For example, you may want to:

  • use private NuGet packages, but you don’t want anyone except your associates to see them.
  • cache a NuGet repository at a server near your build servers
  • leave your build server disconnected from the Internet.

I’ll explain how to set up a private NuGet server on OpenShift and how you can use this NuGet server when building your .NET Core project in OpenShift using s2i-dotnetcore.

Continue reading “Running a NuGet server on OpenShift”


Connecting Kubernetes and Docker

This blog to help my fellow developers who are working on “Docker” and “Kubernetes” simultaneously. Because, they know that Kubernetes runs over docker-engine but there is a catch, that:

1. Containers running on Docker, and

2. Containers running inside of a Kubernetes Pod,

are absolutely running isolated, without even knowing each other’s existence. But, we are developers, so there are chances where we might come across a situation where we desperately need to let the Docker formatted containers communicate with K8s Pod. By communication, I mean the transmission of data from Pod-to-Container and vice-versa, using protocols like TCP, Http, Https, UDP, Sockets, web-sockets and much more.

Continue reading “Connecting Kubernetes and Docker”


How Kubernetes Helps to Enable DevOps

A recent Gartner survey suggests that roughly 50% of the respondents planned to implement continuous delivery and DevOps by year-end 2017 in order to deliver services faster, more often and more reliably. State of DevOps Report by Puppet Labs suggests that high-performing organizations that focus on automation and DevOps are able to reduce their lead-time for delivering a change by a factor of 440 and deliver services 46 times more often. These results have helped to make DevOps adoption a mainstream enterprise IT phenomena. As a result, today we see DevOps adoption in virtually all industries and company sizes, and the perception of DevOps as a unicorn capability has long vanished.

Continue reading “How Kubernetes Helps to Enable DevOps”


Continuous Integration: A “Typical” Process

Typical CI process

Typical CI process (source:

Continuous Integration (CI) is a phase in the software development cycle where code from different team members or different features are integrated together. This usually involves merging code (integration), building the application and carrying out basic tests all within an ephemeral environment.

Continue reading “Continuous Integration: A “Typical” Process”


The Skinny on Fat, Thin, Hollow, and Uber

“I used WildFly Swarm to shrink my app from 45 megabytes to only 2243 bytes.”

I was recently playing around with various techniques for packaging Java microservices and running on OpenShift using various runtimes and frameworks to illustrate their differences (WildFly Swarm vs. WildFly, Spring Boot vs. the world, etc). Around the same time as I was doing this an internal email list thread ignited discussing some of the differences and using terms like Uber JARs, Thin WARs, Skinny WARs, and a few others. Some folks were highlighting the pros and cons of each, especially the benefits of the thin WAR approach when combined with docker image layers.

Continue reading “The Skinny on Fat, Thin, Hollow, and Uber”