FlexDeploy Loves Containers: Build and Deploy Microservices to Kubernetes Clusters in the Cloud

Use Case

There is a microservice in Olympic Games application showing top 5 countries on the medal table. It consists of two layers: UI and BackEnd. UI is implemented with Oracle Jet and BackEnd is built on top of ADF BC exposing REST services. The task is to build each layer separately, package it into a Docker container and deploy the entire solution with FlexDeploy Pipelines across environments represented by Kubernetes clusters.

• The source code of the microsrvice is stored in GitHub.
• Each microservice layer is configured as a project in FlexDeploy
• Whenever the code is changed, FlexDeploy CI server is triggered and starts building a project
• As the result of the building process FlexDeploy builds a Docker image and pushes it to Docker Hub repository
  • For the UI project the Docker image contains Ubuntu + Nginx + Oracle Jet Web folder
  • For the Backend project the Docker image contains Ubuntu + Tomcat + WAR file
• There is a Release configured in FlexDeploy. The release represents the entire microservice and consists of two projects: UI and Backend correspondently.
• Once the build process is finished FlexDeploy creates a snapshot of the microservice containing yaml files referring to Docker images in the Docker Hub repository.
• FlexDeploy Pipeline uses the snapshot to deploy the microservice (two Docker containers) across environments (Dev, Test, Prod).
• Each environment is a Kubernetes cluster running in the cloud. For Dev we use Oracle Container Engine and for Test and Prod we use Google K8S Engine.

Implementation

The release is referring to a simple pipeline definition (read more on pipelines here):

Alrighty, let’s have a look at the workflows that FlexDeploy uses to build projects, to create Docker images and to push them to the Docker Hub repository. A build workflow for the JetFrondEnd project looks like this:

It fetches the source code from GitHub and builds Oracle Jet application (we are not focusing on this step here). The next step buildImage is putting everything into a container. It invokes FlexDeploy Docker plugin buildImage operation:

So, basically it creates a Docker image with a name provided by a project-scoped workflow property DOCKER_IMAGE and with a tag corresponding to the project build version. It’s going to result in something like this: eugeneflexagon/jsfrontend:1.0.53. The Docker build command operates with Dockerfile stored in the source code and having the following content:
FROM nginx:1.10.2-alpine
COPY web /usr/share/nginx/html
EXPOSE 80


Once the image is built we push it to the repository with pushImage step. The step invokes FlexDeploy Docker plugin pushImage operation:

The end point where this workflow step is being executed has preinstalled Docker engine and it is preconfigured with credentials for the Docker Hub repository.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: olympics-jsfrontend
  namespace: efedorenko
  labels:
    run: olympics-jsfrontend
spec:
  replicas: 1
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      labels:
        run: olympics-jsfrontend
    spec:
      containers:
      - image: ${{DOCKER_IMAGE}}:${{FD_PROJECT_VERSION}}
        imagePullPolicy: Always
        name: olympics-jsfrontend
        ports:
        - containerPort: 80
          protocol: TCP
      imagePullSecrets:
      - name: wrelease
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: olympics-jsfrontend-svc
  namespace: efedorenko
spec:
  selector:
    run: olympics-jsfrontend
  ports:
    - port: 8088
      targetPort: 80
  type: ClusterIP

The name of this template is provided by a project-scoped workflow property DEPLOYMENT_TEMPLATE.

Actually, this is nothing else than a Kubernetes deployment profile. The workflow uses FlexDeploy File plugin to replace ${{}} expression with the exact image name.

The result is a yaml file which is going to be saved to the FlexDeploy artifact repository by the last workflow step saveArtifact.