concepts.md

What are containers?

Containers are a way to package software in a format that can run consistently on any platform. Containers are lightweight, standalone, and executable software packages that include everything needed to run an application: code, runtime, system tools, system libraries, and settings.

## Why use containers?

We use containers to ensure that our software runs consistently across different environments. Containers are a way to package software in a format that can run consistently on any platform. Containers are lightweight, standalone, and executable software packages that include everything needed to run an application: code, runtime, system tools, system libraries, and settings.

How do containers work?

Containers work by isolating the application from the host system. This means that the application can run consistently across different environments. Containers are lightweight, standalone, and executable software packages that include everything needed to run an application: code, runtime, system tools, system libraries, and settings.

How containers were created?

Containers were created using the concept of cgroups (control groups). Cgroups allow for resource isolation and allocation in Linux systems. By using cgroups, containers can have their own isolated view of system resources such as CPU, memory, disk I/O, and network. This isolation ensures that containers can run independently and securely on the same host system, without interfering with each other or the host system itself. Cgroups provide the foundation for containerization technologies like Docker and Kubernetes, enabling the creation and management of lightweight, portable, and scalable containers.

Containers vs Virtual Machines

Containers are similar to virtual machines in that they provide a way to run applications in an isolated environment. However, containers are more lightweight and efficient than virtual machines. Containers share the host system's kernel, which means they don't require a full operating system to run. This makes containers faster to start, use less memory, and require fewer resources than virtual machines. Containers are also more portable than virtual machines, as they can run consistently across different environments.

What are the benefits of using containers?

Containers offer several benefits, including:

• Consistent runtime environment: Containers ensure that applications run consistently across different environments, from development to production.
• Lightweight and efficient: Containers are more lightweight and efficient than virtual machines, as they share the host system's kernel and don't require a full operating system to run.
• Portability: Containers can run consistently across different environments, making them more portable than virtual machines.
• Scalability: Containers can be easily scaled up or down to meet changing demands, making them ideal for modern, cloud-native applications.
• Isolation: Containers isolate applications from the host system, ensuring that they can run independently and securely without interfering with each other or the host system itself.

What are the challenges of using containers?

While containers offer many benefits, they also come with some challenges, including:

• Security: Containers can introduce security risks if not properly configured and managed. It's important to follow best practices for securing containers, such as using minimal base images, scanning for vulnerabilities, and implementing proper access controls.
• Orchestration: Managing and orchestrating containers at scale can be complex. Container orchestration platforms like Kubernetes can help automate the deployment, scaling, and management of containerized applications.
• Networking: Networking containers can be challenging, especially in distributed environments. It's important to design and configure container networking to ensure that containers can communicate with each other and external services.
• Monitoring and logging: Monitoring and logging containers can be more complex than traditional applications, as containers are ephemeral and can be short-lived. It's important to implement proper monitoring and logging solutions to track container performance and troubleshoot issues.

How Containers deal with ressources and file systems?

Containers manage resources and file systems through various mechanisms:

1. Resource isolation: Containers use control groups (cgroups) to allocate and manage system resources such as CPU, memory, disk I/O, and network bandwidth. This ensures that containers have their own isolated view of resources and prevents one container from consuming excessive resources and impacting others.

2. Resource limits: Containers can be assigned resource limits, such as CPU and memory limits, to ensure fair resource allocation and prevent resource starvation. These limits can be set during container creation or dynamically adjusted during runtime.

3. Resource sharing: Containers can share resources with each other, allowing for efficient utilization of system resources. For example, multiple containers can share the same host kernel, reducing the overhead of running multiple operating systems.

4. File system isolation: Containers have their own isolated file system, separate from the host system. This allows applications running inside containers to have their own file system hierarchy, independent of the host system. Containers can also mount specific directories or files from the host system into the container's file system, enabling data sharing and persistence.

5. Container images: Containers are created from container images, which are self-contained packages that include the application code, runtime, dependencies, and file system. These images are typically built using a layered file system, where each layer represents a specific component or change in the image. This layered approach allows for efficient storage and sharing of container images.

Overall, containers provide a lightweight and flexible way to manage resources and file systems, enabling consistent and efficient application deployment across different environments.

What are microservices and how do they relate to containers?

Microservices are an architectural approach to building applications as a collection of small, independent services, each running in its own process and communicating with lightweight mechanisms. Microservices are designed to be loosely coupled, independently deployable, and scalable, making them ideal for modern, cloud-native applications.

Containers are a natural fit for microservices, as they provide a lightweight and portable way to package, deploy, and manage individual microservices. Each microservice can be packaged as a container, with its own isolated runtime environment, dependencies, and file system. This allows microservices to run consistently across different environments and be easily scaled up or down to meet changing demands.