Using Docker and Kubernetes with Clojure Applications

23.6 Using Docker and Kubernetes with Clojure Applications

As experienced Java developers transitioning to Clojure, you are likely familiar with the challenges of deploying applications in a scalable and efficient manner. Docker and Kubernetes have become essential tools in the modern developer’s toolkit, enabling seamless deployment and management of applications in cloud environments. In this section, we will explore how to leverage these technologies to deploy Clojure applications effectively.

Dockerizing Applications

Docker is a platform that allows you to package applications and their dependencies into a standardized unit called a container. This ensures consistency across different environments, from development to production.

Step 1: Setting Up a Dockerfile

A Dockerfile is a script that contains a series of instructions on how to build a Docker image. Let’s create a simple Dockerfile for a Clojure application:

 1# Use the official Clojure image as a base
 2FROM clojure:openjdk-11-lein
 3
 4# Set the working directory
 5WORKDIR /app
 6
 7# Copy the project files
 8COPY . .
 9
10# Resolve dependencies and build the application
11RUN lein deps && lein uberjar
12
13# Specify the command to run the application
14CMD ["java", "-jar", "target/uberjar/my-clojure-app.jar"]

Explanation:

• Base Image: We use clojure:openjdk-11-lein, which includes the JDK and Leiningen, a popular build tool for Clojure.
• Working Directory: Sets the working directory inside the container.
• Copy Files: Copies the project files into the container.
• Build Application: Resolves dependencies and builds the application using Leiningen.
• Run Command: Specifies the command to run the application.

Step 2: Building and Running the Docker Image

To build and run the Docker image, execute the following commands in your terminal:

1# Build the Docker image
2docker build -t my-clojure-app .
3
4# Run the Docker container
5docker run -p 8080:8080 my-clojure-app

Try It Yourself: Modify the Dockerfile to use a different base image or change the application entry point to see how it affects the container behavior.

Kubernetes Fundamentals

Kubernetes is an open-source platform for automating deployment, scaling, and management of containerized applications. It abstracts the underlying infrastructure, allowing you to focus on application logic.

Key Concepts

• Pods: The smallest deployable units in Kubernetes, which can contain one or more containers.
• Deployments: Define the desired state of your application, managing the creation and scaling of pods.
• Services: Provide stable endpoints for accessing pods, enabling service discovery and load balancing.
• ConfigMaps: Store configuration data that can be consumed by your applications.

    graph TD;
	    A[User Request] --> B[Service];
	    B --> C[Pod 1];
	    B --> D[Pod 2];
	    B --> E[Pod 3];

Diagram: Kubernetes Service routing traffic to multiple pods.

Deploying to Kubernetes

Deploying a Dockerized Clojure application to Kubernetes involves creating Kubernetes manifest files that describe the desired state of your application.

Step 1: Creating a Deployment

A Deployment manages the lifecycle of your application pods. Here’s an example manifest file:

 1apiVersion: apps/v1
 2kind: Deployment
 3metadata:
 4  name: my-clojure-app
 5spec:
 6  replicas: 3
 7  selector:
 8    matchLabels:
 9      app: my-clojure-app
10  template:
11    metadata:
12      labels:
13        app: my-clojure-app
14    spec:
15      containers:
16      - name: my-clojure-app
17        image: my-clojure-app:latest
18        ports:
19        - containerPort: 8080

Explanation:

• Replicas: Specifies the number of pod instances to run.
• Selector: Matches pods with the specified labels.
• Template: Defines the pod configuration, including the container image and ports.

Step 2: Creating a Service

A Service exposes your application to external traffic and balances the load across pods.

 1apiVersion: v1
 2kind: Service
 3metadata:
 4  name: my-clojure-app-service
 5spec:
 6  type: LoadBalancer
 7  selector:
 8    app: my-clojure-app
 9  ports:
10  - protocol: TCP
11    port: 80
12    targetPort: 8080

Explanation:

• Type: LoadBalancer exposes the service externally.
• Selector: Matches pods with the specified labels.
• Ports: Maps the external port to the container port.

Deploying to the Cluster

Use kubectl to apply the manifest files and deploy your application:

1# Apply the deployment
2kubectl apply -f deployment.yaml
3
4# Apply the service
5kubectl apply -f service.yaml

Service Discovery and Load Balancing

Kubernetes provides built-in service discovery and load balancing, ensuring that traffic is evenly distributed across available pods. This is achieved through the use of Services, which act as stable endpoints for accessing your application.

Scaling and Self-Healing

Kubernetes automatically manages application scaling and recovery from failures. You can scale your application by adjusting the number of replicas in the Deployment manifest.

1spec:
2  replicas: 5

Kubernetes will ensure that the desired number of pods are running, restarting any failed pods as needed.

Real-World Example

Let’s walk through a practical example of deploying a Clojure application to Kubernetes. We’ll use a simple web application that responds with “Hello, World!”.

Step 1: Create the Clojure Application

Create a new Clojure project using Leiningen:

1lein new app hello-world

Edit the src/hello_world/core.clj file to include a simple HTTP server:

1(ns hello-world.core
2  (:require [ring.adapter.jetty :refer [run-jetty]]
3            [ring.util.response :refer [response]]))
4
5(defn handler [request]
6  (response "Hello, World!"))
7
8(defn -main []
9  (run-jetty handler {:port 8080}))

Step 2: Dockerize the Application

Create a Dockerfile for the application:

1FROM clojure:openjdk-11-lein
2WORKDIR /app
3COPY . .
4RUN lein deps && lein uberjar
5CMD ["java", "-jar", "target/uberjar/hello-world.jar"]

Build and run the Docker image:

1docker build -t hello-world .
2docker run -p 8080:8080 hello-world

Step 3: Deploy to Kubernetes

Create a Deployment manifest:

 1apiVersion: apps/v1
 2kind: Deployment
 3metadata:
 4  name: hello-world
 5spec:
 6  replicas: 3
 7  selector:
 8    matchLabels:
 9      app: hello-world
10  template:
11    metadata:
12      labels:
13        app: hello-world
14    spec:
15      containers:
16      - name: hello-world
17        image: hello-world:latest
18        ports:
19        - containerPort: 8080

Create a Service manifest:

 1apiVersion: v1
 2kind: Service
 3metadata:
 4  name: hello-world-service
 5spec:
 6  type: LoadBalancer
 7  selector:
 8    app: hello-world
 9  ports:
10  - protocol: TCP
11    port: 80
12    targetPort: 8080

Deploy the application:

1kubectl apply -f deployment.yaml
2kubectl apply -f service.yaml

Knowledge Check

• What is the purpose of a Dockerfile?
• How does Kubernetes manage application scaling?
• What is the role of a Service in Kubernetes?

Summary

In this section, we’ve explored how to containerize Clojure applications using Docker and deploy them to Kubernetes. By leveraging these technologies, you can build scalable, efficient, and resilient cloud-native applications. Now that you’ve mastered the basics, consider experimenting with advanced Kubernetes features like ConfigMaps and Secrets to further enhance your deployments.

Further Reading

• Docker Documentation
• Kubernetes Documentation
• Clojure Official Documentation

Quiz: Mastering Docker and Kubernetes with Clojure

By mastering Docker and Kubernetes, you can significantly enhance the deployment and management of your Clojure applications, ensuring they are scalable, resilient, and ready for production environments.