Optimizing Application Deployment with Pipelines, Skaffold and Kubernetes


Posted on Tue, Jul 4, 2023 devops skaffold kubernetes

By automating your deployments, you can free up your time and resources to focus on other tasks, such as improving your application's performance or adding new features.

Skaffold is particularly a good choice for Kubernetes deployments, as it can help you deploy and manage your applications in a consistent and reproducible way.

In this article, we’ll learn how to optimize your deployment process using DevOps pipelines, Skaffold, Docker, Minikube and Kubernetes. Without further ado, let’s get started! ⚡️

Understanding the Key Technologies

Creating an efficient application deployment pipeline requires a firm grasp and combination of technologies. This section delves into the fundamental elements powering streamlined workflows: Kubernetes, Docker, Skaffold, Helm and Minikube. Explore their roles and discover how these tools harmonize to revolutionize your DevOps pipeline.

Deployment with Docker

Docker has revolutionized the way applications are developed, deployed, and managed. Let's explore the significance of Docker and the benefits of containerization for application deployment.

1. A Consistent Development Environment ✅

Docker provides a standardized environment for developers across different machines and operating systems. By packaging an application and its dependencies into a Docker container, developers can ensure consistent behavior and eliminate the notorious "it works on my machine" issue. This consistency streamlines the development process and enhances collaboration.

2. Improved Portability 🫙

Containers created with Docker are portable units that can be run on any platform that supports Docker, be it development laptops, testing servers, or cloud environments. This portability ensures that applications behave consistently across different environments, reducing deployment challenges and simplifying the movement of applications between systems.

3. Enhanced Deployment Speed 🏃

Docker containers are lightweight and have faster startup times compared to traditional virtual machines. This characteristic accelerates the deployment process, allowing organizations to quickly package and deploy applications. With Docker, applications can be up and running in seconds, leading to faster release cycles and reduced time-to-market.

An Introduction to Kubernetes

Kubernetes, commonly referred to as K8s, is an open-source container orchestration platform that plays a pivotal role in managing containerized applications. With its robust set of features and scalability, Kubernetes has become the de facto standard for automating the deployment, scaling, and management of containers in modern software development.

With container orchestration, developers can efficiently deploy and manage applications without getting mired in the complexities of individual container instances.

Kubernetes Role in managing containerized applications

Kubernetes acts as a powerful framework for deploying, scaling, and managing containerized applications. It abstracts away the underlying infrastructure complexities and provides a high-level interface for defining the desired state of applications through declarative configurations.

What is Skaffold ?

Skaffold is a powerful and versatile tool that simplifies the application development and deployment process in Kubernetes environments. It automates the workflow by providing a seamless experience for building, testing, and deploying applications.

1. Streamlined Development 🦾

Skaffold eliminates the need for manual build and deployment tasks, enabling developers to focus on writing code. With Skaffold, changes made to the application code trigger an automatic rebuild and deployment, reducing the development cycle time and increasing productivity.

2. Fast Iterations ⚡

Skaffold's incremental build feature optimizes the development process by only rebuilding and deploying the modified parts of the application. This allows for rapid iterations and quick feedback loops, enabling developers to iterate and refine their code more efficiently.

Skaffold empowers developers by automating the build, test, and deployment processes in Kubernetes environments. Its streamlined development, fast iterations, multi-service coordination, intelligent image management, easy configuration, and developer-friendly tooling make it a valuable tool in the DevOps arsenal, enabling efficient and seamless application development and deployment workflows.

Harnessing the Power of Helm

Helm is a powerful package manager for Kubernetes that simplifies the deployment and management of complex applications. It provides a standardized way to define, install, and upgrade applications using charts, which are packages that contain all the necessary Kubernetes resources and configurations.

Local Kubernetes Development with Minikube

Minikube is a lightweight tool that enables developers to run a single-node Kubernetes cluster locally. It provides an easy way to develop and test Kubernetes applications in a local environment before deploying them to a production cluster.

With Minikube 📦, developers can create a local Kubernetes cluster on their machines, providing a consistent development environment that mirrors the production setup. This enables developers to test their applications locally, reducing the feedback loop and speeding up the development process.

Creating a DevOps Pipeline

Establishing a robust DevOps pipeline is paramount to achieving efficient and reliable software delivery. This section explores the key principles and practices involved in creating a seamless DevOps pipeline. From version control and continuous integration to automated deployment and monitoring, discover how organizations can leverage this transformative approach to accelerate development cycles, enhance collaboration, and drive successful software releases.

Step 1 : Set up the development environment

Before we begin, make sure you have the following tools installed :

If you feel confident that you have met the prerequisites, please proceed to the next section.

Step 2: Create the Java application

Method 1

You can create your Java application using the command below :

gradle init --type java-application --dsl groovy --test-framework junit --project-name my-app

Method 2

Spring initializer is a powerful tool that can help you quickly create Java applications with Spring boot support. It is available in many modern IDE, including VS Code. To create a new Spring boot application in VS Code, simply click on "File" and select "Create Java Project".

Then, follow the prompts to select the desired dependencies and configuration options.

After creating the project, open the project in your preferred IDE. You can import the project as a Gradle project. In the src/main/java directory, create a new package called com.example.myapp.hello, and inside that package, create a new file called HelloController.java with the following content :

package com.example.myapp;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

Step 3: Dockerize your application

  1. In the root directory of your project, create a new file called Dockerfile (without any file extension) and add the following content :

FROM openjdk:20-jdk
WORKDIR /my-app
COPY build/libs/my-app-0.0.1-SNAPSHOT.jar my-app-0.0.1-SNAPSHOT-plain.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "my-app-0.0.1-SNAPSHOT-plain.jar"]

This Dockerfile sets up the base image, copies the built JAR file into the container, exposes port 8080, and sets the entry point to start the Spring Boot application.

  1. Build the Docker image by running the following command in the project's root directory :

docker build -t my-app .

  1. You can then test your app on your local machine by exposing the docker image with the command below : 

docker run -p 8080:8080 my-app

💡

If your setup is correct, you should see the Docker container running on Docker Desktop, if you access http://localhost:8080/hello, you should see your hello world app running as shown below:

Step 4: Set up Skaffold for local development

  1. Create a new file in the root directory of your project called skaffold.yaml and add the following content :

apiVersion: skaffold/v2beta20
kind: Config
metadata:
  name: my-app
build:
  artifacts:
    - image: my-app
      context: .
      docker:
        dockerfile: Dockerfile
deploy:
  kubectl:
    manifests:
      - my-app-chart/templates/*

  1. Create Helm chart by running the command below :

helm create my-app-chart

After creating the chart, install and deploy with following command :

helm install my-app-chart ./my-app-chart

You’ll see an image like the one shown below after successful Helm chart installation :

  1. Finally, start Minikube with the command below :

minikube start

This command starts a local Kubernetes cluster using Minikube. You can confirm this by checking you Docker desktop containers to see if it’s running as shown below :

Step 5: Deploy and test your application

  1. Start the Skaffold dev loop by running the following command in the project's root directory :

skaffold dev

Skaffold will build the Docker image, deploy it to the Minikube cluster, and watch for changes in your code to automatically redeploy.

  1. Test your application by accessing the following URL in your web browser :

<http://localhost/hello>

You should see the message "Hello, World!" displayed in your browser.

That's it! You have successfully created a DevOps pipeline using Java with Spring Boot, Gradle, Docker, Skaffold, Helm, Minikube, and Kubernetes. This pipeline enables you to develop and deploy your application locally for testing and development purposes.

You can download the project file below:

my-app (3).zip22409.8KB

Conclusion

Leveraging DevOps pipelines with the use of Skaffold and Kubernetes allows for efficient and streamlined application deployment. By automating the development workflow, teams can rapidly iterate on their applications while maintaining consistency and scalability.

With the power of containerization and Helm, deployments become portable and manageable, enhancing collaboration and promoting modern software development practices. This optimization leads to faster time-to-market, improved software quality, and better overall customer satisfaction.