Skip to content

Latest commit

 

History

History
79 lines (53 loc) · 2.16 KB

containerization.md

File metadata and controls

79 lines (53 loc) · 2.16 KB

Containerization

Containerization is a technique in software development where applications are packaged with their dependencies and runtime environments into lightweight, portable containers. These containers can then be deployed consistently across different environments, providing isolation, scalability, and easy management.

Let's take an example of containerizing a simple web application using Docker:

Suppose we have a basic web application written in Python using Flask. The directory structure of our application looks like this:

my_flask_app/
|   app.py
|   requirements.txt
|   Dockerfile

app.py contains the Flask application code:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World! This is my Flask web application.'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

requirements.txt lists the dependencies of our application:

Flask==2.0.1

Now, let's write a Dockerfile to containerize our application:

# Use the official Python image as base
FROM python:3.9-slim

# Set the working directory in the container
WORKDIR /app

# Copy the dependencies file to the working directory
COPY requirements.txt .

# Install Flask and other dependencies
RUN pip install --no-cache-dir -r requirements.txt

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

# Expose the port on which the Flask app will run
EXPOSE 5000

# Command to run the Flask application
CMD ["python", "app.py"]

To build and run this Docker container:

  1. Navigate to the directory containing the Dockerfile and application code.

  2. Build the Docker image:

    docker build -t my_flask_app .

  3. Run the Docker container:

    docker run -p 5000:5000 my_flask_app

Now, you can access your Flask web application at http://localhost:5000 in your browser.

This example demonstrates how containerization with Docker allows us to package our application along with its dependencies into a portable and isolated environment. This container can be deployed consistently across different environments, making it easier to manage, scale, and maintain our application.