Containerize the Application#

Running workloads in Kubernetes/OpenShift requires the application to be containerized. Typically, this includes taking a relevant base image, installing application dependencies if not available, copying & building the code and command to run your application executed at runtime.

Objectives#

Containerize your application for deployment on Stakater App Agility Platform (SAAP).

Key Results#

Dockerfile created.
Image built and pushed to image repository

Tutorials#

Consider the stakater-nordmart-review-api application.

git clone https://github.com/stakater-lab/stakater-nordmart-review-api
cd stakter-nordmart-review-api

Lets create a Dockerfile inside the repository folder and delete any existing file.

Decide a base image for your application. Navigate to RedHat Container Registry and Find a suitable image for your application. Since this application is java application. We use maven base image.
```
FROM maven:3.8.6-openjdk-11-slim AS build
```
Use COPY and RUN commands to copy required content to containers filesystem and run commands in containers context.
```
COPY src /usr/src/app/src
COPY pom.xml /usr/src/app
RUN mvn -f /usr/src/app/pom.xml clean package
```
We will use another FROM statement to create a multi-stage build for reducing the overall image size. More info here. With multi-stage builds, you use multiple FROM statements in your Dockerfile. Each FROM instruction can use a different base, and each of them begins a new stage of the build. You can selectively copy artifacts from one stage to another, leaving behind everything you don't want in the final image.
```
FROM registry.access.redhat.com/ubi8/openjdk-11:1.14-10
```

Add labels to your image, if any.

LABEL name="inventory" \
maintainer="Stakater <hello@stakater. com>" \
vendor="Stakater" \
release="1" \
summary="Java Spring boot application"

Set an environment variable with ENV command and set it as working directory.
```
ENV HOME=/opt/app
WORKDIR $HOME
```
Use EXPOSE command to expose a container port, typically this corresponds to port on which application runs.
```
EXPOSE 8080
```
JAR files were generated as a result of mvn package. Copy the artifact generated from build stage.
```
COPY --from=build /usr/src/app/target/*.jar $HOME/artifacts/app.jar
```
Define user.
```
USER 1001
```

Set the Entrypoint

ENTRYPOINT exec java $JAVA_OPTS -jar artifacts/app.jar

Finally, specify the command to be executed when container is created with this image, typically the command to run the application.
```
CMD ["java", "-jar", "artifacts/app.jar"]
```
Run the following command to build the image.
```
docker build -t <app-name>:1.0.0 .
```

Execute the following command to run the image.

Note

To run the application container you need Mongo_DB server running.

# -p flag exposes container port 8080 on your local port 8080
# --env flag allows Mongo_DB necessary environment variables; e.g. MONGO_HOST, MONGO_DB_PASS
docker run -dt -p [<localhost-port>:<container-port>] --env <variable1>=<value> --env <variable2>=<value> <image-name>:1.0.0

Note

If Mongo_DB server is running on your local machine, replace -p flag and it's values with --network="host".

docker run -dt --network="host" --env <variable1>=<value> --env <variable2>=<value> <image-name>:1.0.0

Run a curl command to verify that image is running.
```
curl localhost:8080/api/review/329199
```

Read the following articles for more information: