Containerization

Containerization#

To deploy our code on the AI Builder platform and produce a solution.zip file, containerization of our service or application is required. Docker is the chosen tool for this process.

What is a container?#

A container is a lightweight, portable, and self-sufficient environment that includes everything needed to run a piece of software. Think of it as a box that contains an application and all its dependencies, ensuring it runs consistently across different environments. Because containers include all necessary libraries, tools, and configurations, the application will behave the same way, whether it’s on a developer’s laptop, in a test environment, or in production.

Imagine you have a special lunchbox. This lunchbox has everything you need for lunch: your sandwich, drink, utensils, napkin, and even a little plate. No matter where you take this lunchbox—home, school, work—you always have everything you need for lunch, and it’s always the same.

In software terms:

Your lunchbox = Container The sandwich, drink, utensils, etc. = Application and its dependencies

Containerization using Docker#

Containerization involves encapsulating an application and all its dependencies into a self-contained unit known as a container. This process begins by defining the application’s environment and specifying its dependencies, including libraries, frameworks, and runtime components.

Docker is a powerful platform that facilitates the building, running, and management of containers across various environments, including servers and the cloud. It enables developers to package an application and its dependencies into a standardized unit called a container.

When using Docker for containerization, developers typically create a Dockerfile, a configuration file that outlines the steps required to build the container image. This Dockerfile specifies the base image, copies the application code, and configures any additional settings or dependencies necessary for the application’s operation.

Below is a basic overview of the containerization process using Docker. The process involves writing a Dockerfile based on the application. A Dockerfile is a text file containing a series of instructions for assembling a Docker image. A Docker image is a lightweight, standalone, and executable package that includes everything needed to run a piece of software, such as code, runtime, libraries, and dependencies. The Docker image serves as a template for creating Docker containers, which are instances of Docker images running as isolated processes on the host machine. Together, Dockerfiles, Docker images, and Docker containers ensure consistent and efficient application deployment across different environments.

Docker image

With Docker, you can use the Docker build command to build the container image based on the instructions provided in the Dockerfile. Docker provides a simple and efficient way to build, distribute, and run containerized applications, making it a popular choice for containerization.

Writing a dockerfile#

Here is an example Dockerfile:

# Use an official Node.js runtime as the base image
FROM node:14

# Set the working directory inside the container
WORKDIR /app

# Copy package.json and package-lock.json to the working directory
COPY package*.json ./

# Install dependencies using npm
RUN npm install

# Copy the rest of the application code to the working directory
COPY . .

# Expose port 3000 to the outside world
EXPOSE 3000

# Define the command to run the application when the container starts
CMD ["node", "app.js"]

This simple Dockerfile outlines the following steps:

  • FROM node:14: Specifies the base image for the Dockerfile, in this case, the official Node.js image with version 14.

  • WORKDIR /app: Sets the working directory inside the container, where subsequent commands will be executed.

  • COPY package.json ./**: Copies the package.json and package-lock.json files from the host machine to the /app directory inside the container, facilitating dependency caching during the build process.

  • RUN npm install: Executes npm install inside the container to install the required dependencies.

  • COPY . .: Copies the rest of the application code into the container.

  • EXPOSE 3000: Documents that the container will listen on port 3000 at runtime.

  • CMD [“node”, “app.js”]: Defines the command to run the application when the container starts.

Although this Dockerfile is designed for a Node.js application, the procedure remains similar when working with other languages, such as Python.

Now that we know a bit more about docker, we are ready to apply our knowledge on our example pipeline!

Contents