How to build Linux containers with Docker

A containerization tutorial based on Alpaquita Stream

Linux containers are a powerful solution for

• Software standardization;
• Acceleration of development and testing;
• Effective resource management throughout the whole lifecycle of an application.

We have already discussed the intricacies behind the technology, its advantages, and differences from virtualization in our previous article dedicated to JVM in Linux containers.

Here, we will provide a step-by-step guide to building Linux containers with applications intended for Cloud deployment. As an example, we will use BellSoft’s open-source Alpaquita Stream containers hosted on the Docker Hub Container Image Library.

To complete the guide, you must have the docker daemon installed and running. We will explain how to pull a selected container image from the repository and run it with Java, Python, GCC-based applications, and native images. You can use your own app or create a sample project as shown below.

Linux containers for Java applications

Pull a Docker image

BellSoft provides an extensive selection of Alpaquita Linux images: consult the overview to select an appropriate solution for your application. 

To create a container, run

$ docker image pull docker bellsoft/<repository>:<image_tag>

Start the container with

$ docker run -it --rm bellsoft/<repository>:<image_tag>

Alternatively, utilize a combined command:

$ docker container run --rm -it bellsoft/<repository>:<image_tag>

Suppose you have chosen a Liberica Runtime Container, which includes musl-based Alpaquita Stream (a glibc-based option is also available) and Liberica JDK Lite 11. The command will be as follows: 

$ docker container run --rm -it bellsoft/liberica-runtime-container:jdk-11.0.17-musl

Note that pulling an image is not obligatory, but recommended if you don’t want to pull an image every time you repeat the build process. 

Write a Dockerfile and run the app

By using a JRE image instead of a full JDK to run a Java application, you will reduce the container size by approx. 50%.

So in the Dockerfile for our application, we will specify two images — one for building an app, and another for running it. We will use a standard Spring Petclinic project as a sample.

Write the following Dockerfile:

FROM bellsoft/liberica-runtime-container:jdk-17-stream-musl as builder
WORKDIR /home/myapp
RUN apk add git
RUN git clone https://github.com/spring-projects/spring-petclinic.git
RUN cd spring-petclinic && ./mvnw package
FROM bellsoft/liberica-runtime-container:jre-17-stream-musl
WORKDIR /home/myapp
COPY --from=builder /home/myapp/spring-petclinic/target .
CMD ["java", "-jar", "spring-petclinic-3.0.0-SNAPSHOT.jar"]

Build the app image:

$ docker build --progress plain -t javaappimage .

Now. run the the image:

docker run -p 8080:8080 javaappimage

Done! Open the browser at http://localhost:8080/ to access the Petclinic application.

Linux containers for Native Image

Pull a Docker image

We provide images with Liberica Native Image Kit (NIK), an open-source GraalVM-based utility for converting JVM applications into native executables. Developers who work with native images or consider integrating the technology into their project can pull the following image:

$ docker container run --rm -it bellsoft/liberica-native-image-kit-container:jdk-11-nik-21.3.3-stream-musl

Or any image you deem appropriate depending on the JDK and NIK version and libc implementation (BellSoft’s optimized musl or glibc).

Create a native image

First, let’s write a simple application to be converted into a native executable. Alternatively, use your own project.

public class Example {
    public static void main(String[] args) {
        String str = "Native Image is awesome";
        String reversed = reverseString(str);
        System.out.println("The reversed string is: " + reversed);
    }
    public static String reverseString(String str) {
        if (str.isEmpty())
            return str;
        return reverseString(str.substring(1)) + str.charAt(0);
    }
}

The Dockerfile must contain the following information:

FROM bellsoft/liberica-native-image-kit-container:jdk-11-nik-21.3.3-stream-musl
WORKDIR /home/myapp
COPY Example.java /home/myapp
RUN javac Example.java
RUN native-image Example
FROM bellsoft/alpaquita-linux-base:stream-musl
WORKDIR /home/myapp
COPY --from=0 /home/myapp/example .
CMD ["./example"]

Go to the application directory and run

$ docker build .

Verify the image was created.

$ docker images
REPOSITORY     TAG            IMAGE ID       CREATED              SIZE
<none>         <none>         f03df7351579   About a minute ago   19MB

Tag the newly built image with a meaningful name.

$ docker tag f03df7351579 bellsoft-nik:example-musl
$ docker run -it --rm f03df7351579
The reversed string is: emosewa si egamI evitaN

Linux containers for Python

BellSoft provides Alpaquita Linux images with Python 3.10 and basic Python utilities (pip, setuptools, wheel). Two libc options (BellSoft’s musl perf and glibc) are available.

First, let’s write a simple flask application:

$ cat requirements.txt
flask
markup
jinja2

$ cat test.py
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, Docker!'

Now, write a Dockerfile with the following contents:

FROM bellsoft/alpaquita-linux-python:3.10-stream-musl
WORKDIR /myapp
COPY requirements.txt .
RUN pip3 install -r requirements.txt
COPY test.py .
ENV PATH=/root/.local:$PATH
CMD ["python3", "-m" , "flask", "--app", "./test.py", "run", "--host=0.0.0.0"]

Finally, build a Docker image with this Dockerfile:

$ docker build -t flaskimage .

You can now run your Python application in Docker:

$ docker run -d -p 6000:5000 flaskimage
630ae5583186bf0a5d99c97bca68b41401cf6b4b1d22f770fa4f757d23dc240e
$ curl http://127.0.0.1:6000
Hello, Docker!

Linux containers for GCC

BellSoft provides Alpaquita Linux images with the GCC compiler version 12.2, tools, and libraries for development in C/C++. Two libc options (BellSoft’s musl perf and glibc) are available.

We will use a C++ example to show that our gcc image could be used for building both C++ and C projects.

Our gcc images include the following packages that are not obligatory, but could be useful for building.

First, let’s write a simple C++ program:

$ cat hello.cpp
#include <iostream>
using namespace std;
int main()
{
    cout << "Hello World" << endl;
    return 0;
}

In the Dockerfile, specify an Alpaquita image for building an app, and a base image, which will be used for working with the container further on:

FROM bellsoft/alpaquita-linux-gcc:12.2-stream-musl as builder
WORKDIR /home/myapp
COPY hello.cpp .
RUN g++ hello.cpp -o hello -static

FROM bellsoft/alpaquita-linux-base:stream-musl
WORKDIR /home/myapp
COPY --from=builder /home/myapp/hello .
CMD ["./hello"]

Now, build the Docker container image:

$ docker build -t cppappimage .

Run it with the following command:

$ docker run --rm cppappimage
Hello World 

Conclusion

In this article, we learned how to construct Linux containers with Java, Python, C/C++ applications, and Native Image. We used Alpaquita Stream as a base Linux distribution.

As you can see, containerization with Alpaquita is fast and effortless, and in the end, you get a performant microcontainer that can be used as is or further configured for specific purposes.

If you need to add additional Linux packages, take a look at a detailed APK guide. All Alpaquita packages are verified by BellSoft regarding clean licenses to eliminate the risk of license violation, meaning that Alpaquita is legally safe for enterprise use.

Alpaquita Stream is free to use, but BellSoft also provides commercial support for Alpaquita Cloud Native Platform, — a solution based on Alpaquita and Liberica JDK Lite, — which includes

• Alpaquita LTS versions with minimum four years of bug fixes and updates;
• 24/7 service;
• Emergency patches and fixes;
• Support both for Linux and Java from one vendor.

Click on the button below to learn more about the offer.

Contact us