#docker-compose down

[grif-hawaiian-rolls]

sometimes u just get so filled w thoughts about a pair of characters u gotta just go bonkers ya know

[debian-official]

uh oh i have to docker compose down for changes to go through and I'm scared of losing data

[not-so-bored]

June - week 4

Routine

🛏 Sleep 8+ hours 🟥🟩🟥🟥🟥🟨🟥 ⏰ Wake up earlier than 10:00 🟩🟩🟩🟩🟩🟩🟩 👟 Work ⬛️⬛️🟩⬛️🟩🟩🟩 🇳🇱 Dutch lessons 🟦🟦🟥🟥🟥🟥🟥 🦉 Duolingo: Dutch 🟩🟩🟩🟥🟩🟩🟩 💧 Drops: Dutch 🟩🟩🟩🟥🟩🟩🟩 📚 Reading more than 15 pages 🟩🟩🟩🟩🟩🟩🟩 🧠 Meditation: 5+5 minutes 🟩🟩🟩🟥🟥 🟥🟥🟥🟥🟥 🌐 60-day Language Challenge (which I aim to finish in 6 weeks) by @leavelesstree 🟩🟩🟩🟩🟥🟥🟥🟥🟥🟥 🚲 Cycling 🟥 ☕️ Coffee* ⬛️⬛️⬛️⬛️⬛️⬛️⬛️ *I enjoy an occasional cup of coffee but I need to keep them occasional, which means: up to three cups a week with one day break in between

Special tasks

Backlog

🌐 60-day Language Challenge by @leavelesstree 🟩🟩 🧠 Meditation: 2 minutes 🟩🟩 ‼️🚲 Cycling 🟥🟥🟥 ❗️💡 Reaching out to the Philosophy people 🟥🟥🟥 📞 Dispeling my doubts related to the move (formal) 🟨🟩🟥 ✍️ Editing my WiP 🟥 📃 Drafting my name change request 🟥

New approach

I’ve chosen to break down the task of cleaning my room into smaller, more specific tasks. I’m going to focus on what should be done now, instead of aiming for the general idea of a clean room 🗂 Cleaning my desk 🟥 🧹 Vacuuming my room 🟥 🧽 Cleaning the wall 🟧 (there was an attempt) I’ve decided that registering at a university in my home country is pointless because it wouldn’t serve as a viable backup plan. If I got accepted, I’d need to accept or decline their offer very early on, and it would only add more tasks and stress without providing a safety net

Current tasks

💇‍♂️ Getting a haircut 🟩 🏬 Visiting my previous workplace + buying the cheapest thing I may actually use 🟥🟥 💻 Participating in an online event + asking a question and receiving an answer 🟩🟩🟥 🧙‍♂️ Online meeting 🟩 💶 Learning a specific thing about financial matters in the Netherlands 🟧 📋 Scheduling meetings with people I’d like to see before I leave 🟨 🟧 🟥🟥 🟥🟥 🟥 🟥 👥 Arranging a meeting with my former (primary school) classmates 🟨 📆 Scheduling a call 🟩 📃 Work-related bureaucracy 🟩 (on my side but I think it still needs to be approved) 🧓🏻 Visiting my grandma who lives in another city 🟩 🎟 Event 🟩 💻 Working on my Computer Science project (figuring out how to use docker compose or something similar) 🟥🟥 🔢 Maths in English - Precalculus (Khan Academy) 🟥🟥🟥 📖 Digital Technology and Economy reading list - week 1 🟩🟩🟩🟩🟩 🟩🟥🟥 ✍️ Editing my WiP 🟥 📧 Sharing my WiP with one person to whom I promised it 🟥

[yourservicesinfo]

Docker Migration Services: A Seamless Shift to Containerization

In today’s fast-paced tech world, businesses are continuously looking for ways to boost performance, scalability, and flexibility. One powerful way to achieve this is through Docker migration. Docker helps you containerize applications, making them easier to deploy, manage, and scale. But moving existing apps to Docker can be challenging without the right expertise.

Let’s explore what Docker migration services are, why they matter, and how they can help transform your infrastructure.

What Is Docker Migration?

Docker migration is the process of moving existing applications from traditional environments (like virtual machines or bare-metal servers) to Docker containers. This involves re-architecting applications to work within containers, ensuring compatibility, and streamlining deployments.

Why Migrate to Docker?

Here’s why businesses are choosing Docker migration services:

1. Improved Efficiency

Docker containers are lightweight and use system resources more efficiently than virtual machines.

2. Faster Deployment

Containers can be spun up in seconds, helping your team move faster from development to production.

3. Portability

Docker containers run the same way across different environments – dev, test, and production – minimizing issues.

4. Better Scalability

Easily scale up or down based on demand using container orchestration tools like Kubernetes or Docker Swarm.

5. Cost-Effective

Reduced infrastructure and maintenance costs make Docker a smart choice for businesses of all sizes.

What Do Docker Migration Services Include?

Professional Docker migration services guide you through every step of the migration journey. Here's what’s typically included:

- Assessment & Planning

Analyzing your current environment to identify what can be containerized and how.

- Application Refactoring

Modifying apps to work efficiently within containers without breaking functionality.

- Containerization

Creating Docker images and defining services using Dockerfiles and docker-compose.

- Testing & Validation

Ensuring that the containerized apps function as expected across environments.

- CI/CD Integration

Setting up pipelines to automate testing, building, and deploying containers.

- Training & Support

Helping your team get up to speed with Docker concepts and tools.

Challenges You Might Face

While Docker migration has many benefits, it also comes with some challenges:

Compatibility issues with legacy applications

Security misconfigurations

Learning curve for teams new to containers

Need for monitoring and orchestration setup

This is why having experienced Docker professionals onboard is critical.

Who Needs Docker Migration Services?

Docker migration is ideal for:

Businesses with legacy applications seeking modernization

Startups looking for scalable and portable solutions

DevOps teams aiming to streamline deployments

Enterprises moving towards a microservices architecture

Final Thoughts

Docker migration isn’t just a trend—it’s a smart move for businesses that want agility, reliability, and speed in their development and deployment processes. With expert Docker migration services, you can transition smoothly, minimize downtime, and unlock the full potential of containerization.

[rwahowa]

Postal SMTP install and setup on a virtual server

Postal is a full suite for mail delivery with robust features suited for running a bulk email sending SMTP server. Postal is open source and free. Some of its features are: - UI for maintaining different aspects of your mail server - Runs on containers, hence allows for up and down horizontal scaling - Email security features such as spam and antivirus - IP pools to help you maintain a good sending reputation by sending via multiple IPs - Multitenant support - multiple users, domains and organizations - Monitoring queue for outgoing and incoming mail - Built in DNS setup and monitoring to ensure mail domains are set up correctly List of full postal features

Possible cloud providers to use with Postal

You can use Postal with any VPS or Linux server providers of your choice, however here are some we recommend: Vultr Cloud (Get free $300 credit) - In case your SMTP port is blocked, you can contact Vultr support, and they will open it for you after providing a personal identification method. DigitalOcean (Get free $200 Credit) - You will also need to contact DigitalOcean support for SMTP port to be open for you. Hetzner ( Get free €20) - SMTP port is open for most accounts, if yours isn't, contact the Hetzner support and request for it to be unblocked for you Contabo (Cheapest VPS) - Contabo doesn't block SMTP ports. In case you are unable to send mail, contact support. Interserver

Postal Minimum requirements

- At least 4GB of RAM - At least 2 CPU cores - At least 25GB disk space - You can use docker or any Container runtime app. Ensure Docker Compose plugin is also installed. - Port 25 outbound should be open (A lot of cloud providers block it)

Postal Installation

Should be installed on its own server, meaning, no other items should be running on the server. A fresh server install is recommended. Broad overview of the installation procedure - Install Docker and the other needed apps - Configuration of postal and add DNS entries - Start Postal - Make your first user - Login to the web interface to create virtual mail servers Step by step install Postal Step 1 : Install docker and additional system utilities In this guide, I will use Debian 12 . Feel free to follow along with Ubuntu. The OS to be used does not matter, provided you can install docker or any docker alternative for running container images. Commands for installing Docker on Debian 12 (Read the comments to understand what each command does): #Uninstall any previously installed conflicting software . If you have none of them installed it's ok for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done #Add Docker's official GPG key: sudo apt-get update sudo apt-get install ca-certificates curl -y sudo install -m 0755 -d /etc/apt/keyrings sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc sudo chmod a+r /etc/apt/keyrings/docker.asc #Add the Docker repository to Apt sources: echo "deb https://download.docker.com/linux/debian $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null sudo apt-get update #Install the docker packages sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y #You can verify that the installation is successful by running the hello-world image sudo docker run hello-world Add the current user to the docker group so that you don't have to use sudo when not logged in as the root user. ##Add your current user to the docker group. sudo usermod -aG docker $USER #Reboot the server sudo reboot Finally test if you can run docker without sudo ##Test that you don't need sudo to run docker docker run hello-world Step 2 : Get the postal installation helper repository The Postal installation helper has all the docker compose files and the important bootstrapping tools needed for generating configuration files. Install various needed tools #Install additional system utlities apt install git vim htop curl jq -y Then clone the helper repository. sudo git clone https://github.com/postalserver/install /opt/postal/install sudo ln -s /opt/postal/install/bin/postal /usr/bin/postal Step 3 : Install MariaDB database Here is a sample MariaDB container from the postal docs. But you can use the docker compose file below it. docker run -d --name postal-mariadb -p 127.0.0.1:3306:3306 --restart always -e MARIADB_DATABASE=postal -e MARIADB_ROOT_PASSWORD=postal mariadb Here is a tested mariadb compose file to run a secure MariaDB 11.4 container. You can change the version to any image you prefer. vi docker-compose.yaml services: mariadb: image: mariadb:11.4 container_name: postal-mariadb restart: unless-stopped environment: MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD} volumes: - mariadb_data:/var/lib/mysql network_mode: host # Set to use the host's network mode security_opt: - no-new-privileges:true read_only: true tmpfs: - /tmp - /run/mysqld healthcheck: test: interval: 30s timeout: 10s retries: 5 volumes: mariadb_data: You need to create an environment file with the Database password . To simplify things, postal will use the root user to access the Database.env file example is below. Place it in the same location as the compose file. DB_ROOT_PASSWORD=ExtremelyStrongPasswordHere Run docker compose up -d and ensure the database is healthy. Step 4 : Bootstrap the domain for your Postal web interface & Database configs First add DNS records for your postal domain. The most significant records at this stage are the A and/or AAAA records. This is the domain where you'll be accessing the postal UI and for simplicity will also act as the SMTP server. If using Cloudflare, turn off the Cloudflare proxy. sudo postal bootstrap postal.yourdomain.com The above will generate three files in /opt/postal/config. - postal.yml is the main postal configuration file - signing.key is the private key used to sign various things in Postal - Caddyfile is the configuration for the Caddy web server Open /opt/postal/config/postal.yml and add all the values for DB and other settings. Go through the file and see what else you can edit. At the very least, enter the correct DB details for postal message_db and main_db. Step 5 : Initialize the Postal database and create an admin user postal initialize postal make-user If everything goes well with postal initialize, then celebrate. This is the part where you may face some issues due to DB connection failures. Step 6 : Start running postal # run postal postal start #checking postal status postal status # If you make any config changes in future you can restart postal like so # postal restart Step 7 : Proxy for web traffic To handle web traffic and ensure TLS termination you can use any proxy server of your choice, nginx, traefik , caddy etc. Based on Postal documentation, the following will start up caddy. You can use the compose file below it. Caddy is easy to use and does a lot for you out of the box. Ensure your A records are pointing to your server before running Caddy. docker run -d --name postal-caddy --restart always --network host -v /opt/postal/config/Caddyfile:/etc/caddy/Caddyfile -v /opt/postal/caddy-data:/data caddy Here is a compose file you can use instead of the above docker run command. Name it something like caddy-compose.yaml services: postal-caddy: image: caddy container_name: postal-caddy restart: always network_mode: host volumes: - /opt/postal/config/Caddyfile:/etc/caddy/Caddyfile - /opt/postal/caddy-data:/data You can run it by doing docker compose -f caddy-compose.yaml up -d Now it's time to go to the browser and login. Use the domain, bootstrapped earlier. Add an organization, create server and add a domain. This is done via the UI and it is very straight forward. For every domain you add, ensure to add the DNS records you are provided.

Enable IP Pools

One of the reasons why Postal is great for bulk email sending, is because it allows for sending emails using multiple IPs in a round-robin fashion. Pre-requisites - Ensure the IPs you want to add as part of the pool, are already added to your VPS/server. Every cloud provider has a documentation for adding additional IPs, make sure you follow their guide to add all the IPs to the network. When you run ip a , you should see the IP addresses you intend to use in the pool. Enabling IP pools in the Postal config First step is to enable IP pools settings in the postal configuration, then restart postal. Add the following configuration in the postal.yaml (/opt/postal/config/postal.yml) file to enable pools. If the section postal: , exists, then just add use_ip_pools: true under it. postal: use_ip_pools: true Then restart postal. postal stop && postal start The next step is to go to the postal interface on your browser. A new IP pools link is now visible at the top right corner of your postal dashboard. You can use the IP pools link to add a pool, then assign IP addresses in the pools. A pool could be something like marketing, transactions, billing, general etc. Once the pools are created and IPs assigned to them, you can attach a pool to an organization. This organization can now use the provided IP addresses to send emails. Open up an organization and assign a pool to it. Organizations → choose IPs → choose pools . You can then assign the IP pool to servers from the server's Settings page. You can also use the IP pool to configure IP rules for the organization or server. At any point, if you are lost, look at the Postal documentation. Read the full article

[souhaillaghchimdev]

Using Docker in Software Development

Docker has become a vital tool in modern software development. It allows developers to package applications with all their dependencies into lightweight, portable containers. Whether you're building web applications, APIs, or microservices, Docker can simplify development, testing, and deployment.

What is Docker?

Docker is an open-source platform that enables you to build, ship, and run applications inside containers. Containers are isolated environments that contain everything your app needs—code, libraries, configuration files, and more—ensuring consistent behavior across development and production.

Why Use Docker?

Consistency: Run your app the same way in every environment.

Isolation: Avoid dependency conflicts between projects.

Portability: Docker containers work on any system that supports Docker.

Scalability: Easily scale containerized apps using orchestration tools like Kubernetes.

Faster Development: Spin up and tear down environments quickly.

Basic Docker Concepts

Image: A snapshot of a container. Think of it like a blueprint.

Container: A running instance of an image.

Dockerfile: A text file with instructions to build an image.

Volume: A persistent data storage system for containers.

Docker Hub: A cloud-based registry for storing and sharing Docker images.

Example: Dockerizing a Simple Python App

Let’s say you have a Python app called app.py: # app.py print("Hello from Docker!")

Create a Dockerfile: # Dockerfile FROM python:3.10-slim COPY app.py . CMD ["python", "app.py"]

Then build and run your Docker container: docker build -t hello-docker . docker run hello-docker

This will print Hello from Docker! in your terminal.

Popular Use Cases

Running databases (MySQL, PostgreSQL, MongoDB)

Hosting development environments

CI/CD pipelines

Deploying microservices

Local testing for APIs and apps

Essential Docker Commands

docker build -t <name> . — Build an image from a Dockerfile

docker run <image> — Run a container from an image

docker ps — List running containers

docker stop <container_id> — Stop a running container

docker exec -it <container_id> bash — Access the container shell

Docker Compose

Docker Compose allows you to run multi-container apps easily. Define all your services in a single docker-compose.yml file and launch them with one command: version: '3' services: web: build: . ports: - "5000:5000" db: image: postgres

Start everything with:docker-compose up

Best Practices

Use lightweight base images (e.g., Alpine)

Keep your Dockerfiles clean and minimal

Ignore unnecessary files with .dockerignore

Use multi-stage builds for smaller images

Regularly clean up unused images and containers

Conclusion

Docker empowers developers to work smarter, not harder. It eliminates "it works on my machine" problems and simplifies the development lifecycle. Once you start using Docker, you'll wonder how you ever lived without it!

[lowendbox]

Running your own infrastructure can be empowering. Whether you're managing a SaaS side project, self-hosting your favorite tools like Nextcloud or Uptime Kuma, running a game server, or just learning by doing, owning your stack gives you full control and flexibility. But it also comes with a cost. The good news? That cost doesn’t have to be high. One of the core values of the LowEndBox community is getting the most out of every dollar. Many of our readers are developers, sysadmins, hobbyists, or small businesses trying to stretch limited infrastructure budgets. That’s why self-hosting is so popular here—it’s customizable, private, and with the right strategy, surprisingly affordable. In this article, we’ll walk through seven practical ways to reduce your self-hosting costs. Whether you’re just starting out or already managing multiple VPSes, these tactics will help you trim your expenses without sacrificing performance or reliability. These aren't just random tips, they’re based on real-world strategies we see in action across the LowEndBox and LowEndTalk communities every day. 1. Use Spot or Preemptible Instances for Non-Critical Workloads Some providers offer deep discounts on “spot” instances, VPSes or cloud servers that can be reclaimed at any time. These are perfect for bursty workloads, short-term batch jobs, or backup processing where uptime isn’t mission-critical. Providers like Oracle Cloud and even some on the LowEndBox VPS deals page offer cost-effective servers that can be used this way. 2. Consolidate with Docker or Lightweight VMs Instead of spinning up multiple VPS instances, try consolidating services using containers or lightweight VMs (like those on Proxmox, LXC, or KVM). You’ll pay for fewer VPSes and get better performance by optimizing your resources. Tools like Docker Compose or Portainer make it easy to manage your stack efficiently. 3. Deploy to Cheaper Regions Server pricing often varies based on data center location. Consider moving your workloads to lower-cost regions like Eastern Europe, Southeast Asia, or Midwest US cities. Just make sure latency still meets your needs. LowEndBox regularly features hosts offering ultra-affordable plans in these locations. 4. Pay Annually When It Makes Sense Some providers offer steep discounts for annual or multi-year plans, sometimes as much as 30–50% compared to monthly billing. If your project is long-term, this can be a great way to save. Before you commit, check if the provider is reputable. User reviews on LowEndTalk can help you make a smart call. 5. Take Advantage of Free Tiers You’d be surprised how far you can go on free infrastructure these days. Services like: Cloudflare Tunnels (free remote access to local servers) Oracle Cloud Free Tier (includes 4 vCPUs and 24GB RAM!) GitHub Actions for automation Hetzner’s free DNS or Backblaze’s generous free storage Combined with a $3–$5 VPS, these tools can power an entire workflow on a shoestring budget. 6. Monitor Idle Resources It’s easy to let unused servers pile up. Get into the habit of monitoring resource usage and cleaning house monthly. If a VPS is sitting idle, shut it down or consolidate it. Tools like Netdata, Grafana + Prometheus, or even htop and ncdu can help you track usage and trim the fat. 7. Watch LowEndBox for Deals (Seriously) This isn’t just self-promo, it’s reality, LowEndBox has been the global market leader in broadcasting great deals for our readers for years. Our team at LowEndBox digs up exclusive discounts, coupon codes, and budget-friendly hosting options from around the world every week. Whether it’s a $15/year NAT VPS, or a powerful GPU server for AI workloads under $70/month, we help you find the right provider at the right price. Bonus: we also post guides and how-tos to help you squeeze the most out of your stack. Final Thoughts Cutting costs doesn’t mean sacrificing quality. With the right mix of smart planning, efficient tooling, and a bit of deal hunting, you can run powerful, scalable infrastructure on a micro-budget. Got your own cost-saving tip? Share it with the community over at LowEndTalk! https://lowendbox.com/blog/1-vps-1-usd-vps-per-month/ https://lowendbox.com/blog/2-usd-vps-cheap-vps-under-2-month/ https://lowendbox.com/best-cheap-vps-hosting-updated-2020/ Read the full article

[rishabhtpt]

Mastering Docker: A Complete Guide for Beginners

Docker has revolutionized the way developers build, package, and deploy applications. It simplifies software deployment by allowing applications to run in isolated environments called containers. This Docker tutorial will provide beginners with a complete understanding of Docker, how it works, and how to use it effectively.

What is Docker?

Docker is an open-source platform designed to automate the deployment of applications inside lightweight, portable containers. It ensures that applications run consistently across different computing environments.

Key Features of Docker:

Portability: Containers work across different platforms without modification.

Efficiency: Containers share the host OS kernel, reducing resource consumption.

Scalability: Easy to scale applications up or down based on demand.

Isolation: Each container runs in its own isolated environment.

Why Use Docker?

Before Docker, applications were often deployed using virtual machines (VMs), which were resource-intensive. Docker provides a more lightweight and efficient alternative by using containerization.

Benefits of Docker:

Faster Deployment: Containers launch within seconds.

Consistency: Works the same on different systems, eliminating “it works on my machine” issues.

Better Resource Utilization: Uses fewer resources than traditional VMs.

Simplified Dependency Management: All dependencies are packaged within the container.

Installing Docker

To start using Docker, you need to install it on your system. Follow these steps based on your OS:

Windows & macOS:

Download Docker Desktop from Docker’s official website.

Install Docker and restart your system.

Verify installation by running:

docker --version

Linux:

Update the package database:

sudo apt update

Install Docker:

sudo apt install docker.io -y

Start the Docker service:

sudo systemctl start docker

sudo systemctl enable docker

Verify installation:

docker --version

Understanding Docker Components

Docker consists of several core components that help in container management.

1. Docker Engine

The runtime that builds and runs containers.

2. Docker Images

A Docker Image is a blueprint for creating containers. It contains the application code, dependencies, and configurations.

3. Docker Containers

A Docker Container is a running instance of an image. It runs in an isolated environment.

4. Docker Hub

A cloud-based registry where Docker images are stored and shared.

Basic Docker Commands

Here are some essential Docker commands to help you get started:

1. Check Docker Version

docker --version

2. Pull an Image from Docker Hub

docker pull ubuntu

3. List Available Images

docker images

4. Run a Container

docker run -it ubuntu bash

This command runs an Ubuntu container and opens an interactive shell.

5. List Running Containers

docker ps

6. Stop a Running Container

docker stop <container_id>

7. Remove a Container

docker rm <container_id>

8. Remove an Image

docker rmi ubuntu

Creating a Docker Container from a Custom Image

To create a custom container, follow these steps:

1. Create a Dockerfile

A Dockerfile is a script containing instructions to build an image.

Create a Dockerfile with the following content:

# Use an official Python runtime as a parent image

FROM python:3.9

# Set the working directory

WORKDIR /app

# Copy the current directory contents into the container at /app

COPY . /app

# Install any dependencies

RUN pip install --no-cache-dir -r requirements.txt

# Run the application

CMD ["python", "app.py"]

2. Build the Docker Image

Run the following command:

docker build -t my-python-app .

3. Run a Container from the Image

docker run -p 5000:5000 my-python-app

Managing Data with Docker Volumes

Docker volumes are used for persistent storage. To create and use a volume:

Create a volume:

docker volume create my_volume

Attach it to a container:

docker run -v my_volume:/app/data ubuntu

Check available volumes:

docker volume ls

Docker Compose: Managing Multi-Container Applications

Docker Compose is a tool used to define and manage multi-container applications.

Example docker-compose.yml:

version: '3'

services:

  web:

    image: nginx

    ports:

      - "8080:80"

  db:

    image: mysql

    environment:

      MYSQL_ROOT_PASSWORD: password

To start the services, run:

docker-compose up

Best Practices for Using Docker

Use Official Images: Minimize security risks by using verified images from Docker Hub.

Minimize Image Size: Use lightweight base images like alpine.

Keep Containers Stateless: Store persistent data in volumes.

Remove Unused Containers and Images: Clean up using:

docker system prune -a

Limit Container Resources: Use flags like --memory and --cpu-shares to allocate resources efficiently.

Conclusion

Docker is an essential tool for modern software development, enabling efficient and scalable application deployment. This Docker tutorial For beginner covered the basics, from installation to container management and best practices. Whether you are new to containerization or looking to refine your skills, mastering Docker will significantly improve your workflow.

Start experimenting with Docker today and take your development process to the next level!

[rackmount-official-my-ass]

For my dear followers! There’s a docker compose config in the Reddit thread. Sic your spare bandwidth on this for a good cause. Picture pulling a book off the bonfire for every doc archived.

I’m setting it up on my unused cloud cap. I would presume it’s generally network-bottlenecked, since it just downloads and then uploads somewhere else, using disk as a temp cache. The images are pulling awfully slowly at the moment.

Update: The container image also runs package installation and setup steps once you start it, so expect some lag between Compose turning up the ct and actually downloading docs. Looks like several minutes of setup, but it’s automated. I’ll update later with my findings on optimal replica count.

Update: It turns out the network seems rather underutilized? And the CPU load is sporadic, and probably the bottleneck. On 3 cores/4 gigs, I'm seeing a load avg of ~2.75 with 30 replicas and 6 concurrent items. 4c/8g, 36/6, load ~3. I'll try tweaking the "concurrent items" parameter and see what happens.

Update: Looks like concurrency is capped at 6 items. Bumping up to 30 ct/3 core and 36 ct/4 core, looking good. Would recommend starting small and scaling up by increments; the container init will peg your CPUs and slow the whole process down. Have fun!

Help archive US government data

I'm sure this is probably old news to the computer obsessed queer people that mostly make up my follower base, but this reddit post is the simplest guide I've seen on how to help archive US government data.

Note that this doesn't save anything to your computer- it downloads stuff, reuploads it to archive servers, and then deletes it locally.

This is probably the easiest idle way to help secure data that is being purged right now. I got it running on my machine easily. If anyone has any other suggestions, please let me know.

[learning-code-ficusoft]

Using Docker for Full Stack Development and Deployment

1. Introduction to Docker

What is Docker? Docker is an open-source platform that automates the deployment, scaling, and management of applications inside containers. A container packages your application and its dependencies, ensuring it runs consistently across different computing environments.

Containers vs Virtual Machines (VMs)

Containers are lightweight and use fewer resources than VMs because they share the host operating system’s kernel, while VMs simulate an entire operating system. Containers are more efficient and easier to deploy.

Docker containers provide faster startup times, less overhead, and portability across development, staging, and production environments.

Benefits of Docker in Full Stack Development

Portability: Docker ensures that your application runs the same way regardless of the environment (dev, test, or production).

Consistency: Developers can share Dockerfiles to create identical environments for different developers.

Scalability: Docker containers can be quickly replicated, allowing your application to scale horizontally without a lot of overhead.

Isolation: Docker containers provide isolated environments for each part of your application, ensuring that dependencies don’t conflict.

2. Setting Up Docker for Full Stack Applications

Installing Docker and Docker Compose

Docker can be installed on any system (Windows, macOS, Linux). Provide steps for installing Docker and Docker Compose (which simplifies multi-container management).

Commands:

docker --version to check the installed Docker version.

docker-compose --version to check the Docker Compose version.

Setting Up Project Structure

Organize your project into different directories (e.g., /frontend, /backend, /db).

Each service will have its own Dockerfile and configuration file for Docker Compose.

3. Creating Dockerfiles for Frontend and Backend

Dockerfile for the Frontend:

For a React/Angular app:

Dockerfile

FROM node:14 WORKDIR /app COPY package*.json ./ RUN npm install COPY . . EXPOSE 3000 CMD ["npm", "start"]

This Dockerfile installs Node.js dependencies, copies the application, exposes the appropriate port, and starts the server.

Dockerfile for the Backend:

For a Python Flask app

Dockerfile

FROM python:3.9 WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY . . EXPOSE 5000 CMD ["python", "app.py"]

For a Java Spring Boot app:

Dockerfile

FROM openjdk:11 WORKDIR /app COPY target/my-app.jar my-app.jar EXPOSE 8080 CMD ["java", "-jar", "my-app.jar"]

This Dockerfile installs the necessary dependencies, copies the code, exposes the necessary port, and runs the app.

4. Docker Compose for Multi-Container Applications

What is Docker Compose? Docker Compose is a tool for defining and running multi-container Docker applications. With a docker-compose.yml file, you can configure services, networks, and volumes.

docker-compose.yml Example:

yaml

version: "3" services: frontend: build: context: ./frontend ports: - "3000:3000" backend: build: context: ./backend ports: - "5000:5000" depends_on: - db db: image: postgres environment: POSTGRES_USER: user POSTGRES_PASSWORD: password POSTGRES_DB: mydb

This YAML file defines three services: frontend, backend, and a PostgreSQL database. It also sets up networking and environment variables.

5. Building and Running Docker Containers

Building Docker Images:

Use docker build -t <image_name> <path> to build images.

For example:

bash

docker build -t frontend ./frontend docker build -t backend ./backend

Running Containers:

You can run individual containers using docker run or use Docker Compose to start all services:

bash

docker-compose up

Use docker ps to list running containers, and docker logs <container_id> to check logs.

Stopping and Removing Containers:

Use docker stop <container_id> and docker rm <container_id> to stop and remove containers.

With Docker Compose: docker-compose down to stop and remove all services.

6. Dockerizing Databases

Running Databases in Docker:

You can easily run databases like PostgreSQL, MySQL, or MongoDB as Docker containers.

Example for PostgreSQL in docker-compose.yml:

yaml

db: image: postgres environment: POSTGRES_USER: user POSTGRES_PASSWORD: password POSTGRES_DB: mydb

Persistent Storage with Docker Volumes:

Use Docker volumes to persist database data even when containers are stopped or removed:

yaml

volumes: - db_data:/var/lib/postgresql/data

Define the volume at the bottom of the file:

yaml

volumes: db_data:

Connecting Backend to Databases:

Your backend services can access databases via Docker networking. In the backend service, refer to the database by its service name (e.g., db).

7. Continuous Integration and Deployment (CI/CD) with Docker

Setting Up a CI/CD Pipeline:

Use Docker in CI/CD pipelines to ensure consistency across environments.

Example: GitHub Actions or Jenkins pipeline using Docker to build and push images.

Example .github/workflows/docker.yml:

yaml

name: CI/CD Pipeline on: [push] jobs: build: runs-on: ubuntu-latest steps: - name: Checkout Code uses: actions/checkout@v2 - name: Build Docker Image run: docker build -t myapp . - name: Push Docker Image run: docker push myapp

Automating Deployment:

Once images are built and pushed to a Docker registry (e.g., Docker Hub, Amazon ECR), they can be pulled into your production or staging environment.

8. Scaling Applications with Docker

Docker Swarm for Orchestration:

Docker Swarm is a native clustering and orchestration tool for Docker. You can scale your services by specifying the number of replicas.

Example:

bash

docker service scale myapp=5

Kubernetes for Advanced Orchestration:

Kubernetes (K8s) is more complex but offers greater scalability and fault tolerance. It can manage Docker containers at scale.

Load Balancing and Service Discovery:

Use Docker Swarm or Kubernetes to automatically load balance traffic to different container replicas.

9. Best Practices

Optimizing Docker Images:

Use smaller base images (e.g., alpine images) to reduce image size.

Use multi-stage builds to avoid unnecessary dependencies in the final image.

Environment Variables and Secrets Management:

Store sensitive data like API keys or database credentials in Docker secrets or environment variables rather than hardcoding them.

Logging and Monitoring:

Use tools like Docker’s built-in logging drivers, or integrate with ELK stack (Elasticsearch, Logstash, Kibana) for advanced logging.

For monitoring, tools like Prometheus and Grafana can be used to track Docker container metrics.

10. Conclusion

Why Use Docker in Full Stack Development? Docker simplifies the management of complex full-stack applications by ensuring consistent environments across all stages of development. It also offers significant performance benefits and scalability options.

Recommendations:

Encourage users to integrate Docker with CI/CD pipelines for automated builds and deployment.

Mention the use of Docker for microservices architecture, enabling easy scaling and management of individual services.

WEBSITE: https://www.ficusoft.in/full-stack-developer-course-in-chennai/

[prabhatdavian-blog]

Docker MasterClass: Docker, Compose, SWARM, and DevOps

Docker has revolutionized the way we think about software development and deployment. By providing a consistent environment for applications, Docker allows developers to create, deploy, and run applications inside containers, ensuring that they work seamlessly across different computing environments. In this Docker MasterClass, we’ll explore Docker’s core components, including Docker Compose and Docker Swarm, and understand how Docker fits into the broader DevOps ecosystem.

Introduction to Docker

Docker is an open-source platform that automates the deployment of applications inside lightweight, portable containers. These containers package an application and its dependencies together, making it easy to move between development, testing, and production environments. Docker's efficiency and flexibility have made it a staple in modern software development.

Docker’s Core Components

Docker Engine

At the heart of Docker is the Docker Engine, a client-server application that builds, runs, and manages Docker containers. The Docker Engine consists of three components:

Docker Daemon: The background service that runs containers and manages Docker objects.

Docker CLI: The command-line interface used to interact with the Docker Daemon.

REST API: Allows communication with the Docker Daemon via HTTP requests.

Docker Images

Docker images are read-only templates that contain the instructions for creating a container. They include everything needed to run an application, including the code, runtime, libraries, and environment variables. Images are stored in a Docker registry, such as Docker Hub, from which they can be pulled and used to create containers.

Docker Containers

A Docker container is a running instance of a Docker image. Containers are isolated, secure, and can be easily started, stopped, and moved between environments. Because they contain everything needed to run an application, they ensure consistency across different stages of development and deployment.

Docker Compose: Managing Multi-Container Applications

Docker Compose is a tool that allows you to define and manage multi-container Docker applications. With Docker Compose, you can specify a multi-container application’s services, networks, and volumes in a single YAML file, known as docker-compose.yml.

Key Features of Docker Compose

Declarative Configuration: Define services, networks, and volumes in a straightforward YAML file.

Dependency Management: Docker Compose automatically starts services in the correct order, based on their dependencies.

Environment Variables: Easily pass environment variables into services, making configuration flexible and adaptable.

Scaling: Docker Compose allows you to scale services to multiple instances with a single command.

Docker Swarm: Orchestrating Containers

Docker Swarm is Docker’s native clustering and orchestration tool. It allows you to manage a cluster of Docker nodes as a single virtual system, simplifying the deployment and scaling of multi-container applications across multiple hosts.

Key Features of Docker Swarm

Service Discovery: Automatically discovers and loads balances services across the cluster.

Scaling: Easily scale services up or down by adding or removing nodes from the Swarm.

Rolling Updates: Perform updates to services without downtime by gradually replacing old containers with new ones.

Fault Tolerance: Redistributes workloads across the remaining nodes if a node fails.

Setting Up a Docker Swarm Cluster

To create a Docker Swarm, you need to initialize a Swarm manager on one node and then join additional nodes as workers:

bash

Copy code

# Initialize the Swarm manager docker swarm init # Add a worker node to the Swarm docker swarm join --token <worker-token> <manager-IP>:2377

Once your Swarm is set up, you can deploy a service across the cluster:

bash

Copy code

docker service create --replicas 3 --name my-service nginx:latest

This command creates a service named my-service with three replicas, distributed across the available nodes.

Docker in DevOps

Docker is an integral part of the DevOps pipeline, where it is used to streamline the process of developing, testing, and deploying applications.

Continuous Integration and Continuous Deployment (CI/CD)

In a CI/CD pipeline, Docker ensures consistency between development and production environments. Docker containers can be built, tested, and deployed automatically as part of the pipeline, reducing the likelihood of “works on my machine” issues.

Infrastructure as Code (IaC)

With Docker, infrastructure can be defined and managed as code. Dockerfiles, Docker Compose files, and Swarm configurations can be version-controlled and automated, allowing for reproducible and consistent deployments.

Collaboration and Consistency

Docker promotes collaboration between development, operations, and testing teams by providing a standardized environment. Teams can share Docker images and Compose files, ensuring that everyone is working with the same setup, from local development to production.

Advanced Docker Concepts

Docker Networking

Docker provides several networking modes, including bridge, host, and overlay networks. These modes allow containers to communicate with each other and with external networks, depending on the needs of your application.

Docker Volumes

Docker volumes are used to persist data generated by Docker containers. Volumes are independent of the container’s lifecycle, allowing data to persist even if the container is deleted or recreated.

Security Best Practices

Use Official Images: Prefer official Docker images from trusted sources to minimize security risks.

Limit Container Privileges: Run containers with the least privileges necessary to reduce the attack surface.

Regularly Update Containers: Keep your Docker images and containers up to date to protect against known vulnerabilities.

Conclusion

Docker has become a cornerstone of modern software development and deployment, providing a consistent, scalable, and secure platform for managing applications. By mastering Docker, Docker Compose, Docker Swarm, and integrating these tools into your DevOps pipeline, you can streamline your workflows, improve collaboration, and deploy applications with confidence.

Whether you're just starting out or looking to deepen your Docker knowledge, this MasterClass provides a comprehensive foundation to take your skills to the next level. Embrace the power of Docker, and transform the way you build, ship, and run applications.

[qcs01]

Embracing the Future with Cloud Native Services

Introduction

In the rapidly evolving landscape of technology, businesses are constantly seeking ways to innovate and stay ahead of the curve. One of the most transformative advancements in recent years is the advent of cloud-native services. As organizations strive for agility, scalability, and resilience, cloud-native services offer the perfect solution. In this blog post, we will explore what cloud-native services are, their benefits, and how they are revolutionizing the way we build and deploy applications.

What are Cloud Native Services?

Cloud-native services refer to the design and deployment of applications specifically for cloud environments. Unlike traditional applications that are built to run on specific hardware or operating systems, cloud-native applications are designed to take full advantage of the cloud's capabilities. These services are built using microservices architecture, which allows for the creation of modular and loosely coupled components that can be independently developed, deployed, and scaled.

Key Characteristics of Cloud Native Services

Microservices Architecture: Cloud-native applications are composed of small, independent services that communicate with each other through APIs. This modular approach enables teams to develop, test, and deploy services independently, resulting in faster development cycles and improved fault isolation.

Containerization: Containers are a fundamental aspect of cloud-native services. They package applications and their dependencies into a single, portable unit, ensuring consistency across different environments. Popular containerization platforms include Docker and Kubernetes.

DevOps Practices: Cloud-native development embraces DevOps principles, fostering collaboration between development and operations teams. Continuous integration and continuous deployment (CI/CD) pipelines automate the build, test, and deployment processes, enabling rapid and reliable delivery of new features and updates.

Scalability and Resilience: Cloud-native services are designed to scale horizontally, allowing applications to handle increased workloads by adding more instances of services. Additionally, they are built with resilience in mind, incorporating features like automatic failover and self-healing capabilities.

Benefits of Cloud Native Services

Agility: Cloud-native services empower organizations to respond quickly to changing market demands. The modular nature of microservices allows for rapid development, testing, and deployment, reducing time-to-market for new features and updates.

Scalability: With cloud-native services, scaling applications is seamless and cost-effective. Organizations can dynamically allocate resources based on demand, ensuring optimal performance and cost efficiency.

Resilience: Cloud-native applications are inherently resilient, designed to withstand failures and recover quickly. The use of container orchestration platforms like Kubernetes ensures that applications remain available even in the face of infrastructure issues.

Cost Efficiency: By leveraging the pay-as-you-go model of cloud services, organizations can optimize their infrastructure costs. Cloud-native applications can scale up or down based on usage, eliminating the need for over-provisioning resources.

Innovation: Cloud-native services enable organizations to experiment with new technologies and approaches. The flexibility and agility of cloud-native development foster a culture of innovation, allowing businesses to stay ahead of the competition.

Use Cases of Cloud Native Services

E-commerce Platforms: E-commerce businesses benefit from cloud-native services by achieving high scalability during peak shopping seasons. The ability to handle increased traffic and transactions ensures a seamless customer experience.

Financial Services: Banks and financial institutions leverage cloud-native applications for real-time transaction processing, fraud detection, and personalized customer services. The scalability and resilience of cloud-native services ensure uninterrupted operations.

Healthcare: Cloud-native services support the healthcare industry by enabling secure and scalable storage of patient data, real-time analytics, and telemedicine applications. The agility of cloud-native development accelerates the deployment of innovative healthcare solutions.

Media and Entertainment: Streaming platforms and content delivery networks rely on cloud-native services to deliver high-quality media experiences to users worldwide. The ability to scale resources based on user demand ensures smooth and uninterrupted streaming.

Conclusion

Cloud-native services represent a paradigm shift in how we build, deploy, and manage applications. By embracing cloud-native principles, organizations can achieve unprecedented levels of agility, scalability, and resilience. As the technology landscape continues to evolve, cloud-native services will play a pivotal role in driving innovation and transforming industries.

For more details click www.hawkstack.com

[sk1998-itdigest]

Understanding Container Orchestration: A Beginner’s Guide

Introduction to Container Orchestration

In today's digital era, efficiently managing complex applications composed of multiple containers with unique requirements and dependencies is crucial. Manually handling and deploying a growing number of containers can result in errors and inefficiencies. Container orchestration emerges as a vital solution to these challenges.

Defining Container Orchestration

Container orchestration automates the deployment, management, scaling, and networking of containers. Containers are lightweight, isolated environments that package applications and their dependencies, ensuring seamless operation across diverse computing environments.

With numerous containers representing different parts of an application, orchestration is essential to deploy these containers across various machines, allocate appropriate resources, and facilitate communication between them. It's akin to a conductor leading an orchestra. Without orchestration, managing containers would be chaotic and inefficient.

Popular container orchestration tools include Kubernetes and Docker Swarm.

The Importance of Container Orchestration

Managing containers in a production environment can quickly become complex, especially with microservices—independent processes running in separate containers. Large-scale systems can involve hundreds or thousands of containers. Manual management is impractical, making orchestration essential. It automates tasks, reducing operational complexity for DevOps teams who need to work quickly and efficiently.

Advantages of Container Orchestration

Streamlined Application Development: Orchestration tools accelerate the development process, making it more consistent and repeatable, ideal for agile development approaches like DevOps.

Scalability: Easily scale container deployments up or down as needed. Managed cloud services provide additional scalability, enabling on-demand infrastructure adjustments.

Cost-Effectiveness: Containers are resource-efficient, saving on infrastructure and overhead costs. Orchestration platforms also reduce human resource expenses and time.

Security: Manage security policies across different platforms, minimizing human errors and enhancing security. Containers isolate application processes, making it harder for attackers to infiltrate.

High Availability: Quickly identify and resolve infrastructure failures. Orchestration tools automatically restart or replace malfunctioning containers, ensuring continuous application availability.

Productivity: Automate repetitive tasks, simplifying the installation, management, and maintenance of containers, allowing more focus on developing applications.

How Container Orchestration Works

Using YAML or JSON files, container orchestration tools like Kubernetes specify how an application should be configured. These configuration files define where to find container images, how to set up the network, and where to store logs.

When deploying a new container, the orchestration tool determines the appropriate cluster and host based on specified requirements. It then manages the container's lifecycle according to the defined configurations.

Kubernetes patterns facilitate the management of container-based applications' configuration, lifecycle, and scalability. These patterns are essential tools for building robust systems with Kubernetes, which can operate in any container-running environment, including on-premise servers and public or private clouds.

Container Orchestration Using Kubernetes

Kubernetes, an open-source orchestration platform, is widely adopted for building and managing containerized applications and services. It allows easy scaling, scheduling, and monitoring of containers. As of 2022, 96% of Sysdig global customer containers are deployed on Kubernetes.

Other container orchestration options include Apache Mesos and Docker Swarm, but Kubernetes is favored for its extensive container capabilities and support for cloud-native application development. Kubernetes is also highly extensible and portable, compatible with advanced technologies like service meshes. Its declarative nature enables developers and administrators to define desired system behaviors, which Kubernetes then implements in real-time.

Conclusion

Container orchestration is a transformative approach to designing and managing applications. It simplifies deployment processes, enhances scalability, improves security, and optimizes resource utilization. As the industry evolves, adopting orchestration is crucial for organizations aiming to innovate and deliver exceptional software solutions.

[apexon-digital]

Unleashing the Power of Cloud-Native Application Development

In today's digital landscape, where agility, scalability, and efficiency are paramount, businesses are increasingly turning to cloud-native application development to gain a competitive edge. With the rapid evolution of cloud technologies, traditional monolithic applications are becoming outdated relics of the past. Instead, organizations are embracing the cloud-native approach to build applications that are inherently scalable, resilient, and flexible. In this blog, we'll explore the essence of cloud-native application development, its benefits, and how it's transforming the way we build and deploy software solutions.

Understanding Cloud-Native Application Development

Cloud-native application development is more than just deploying applications in the cloud. It's a methodology that leverages cloud computing principles to design, develop, deploy, and manage applications. At its core, cloud-native development focuses on building applications as a set of loosely coupled microservices, each running in its own container and independently deployable. This architectural style enables faster development cycles, greater scalability, and improved resilience compared to traditional monolithic applications.

Key Characteristics of Cloud-Native Applications

Microservices Architecture: Cloud-native applications are composed of small, independent services that can be developed, deployed, and scaled independently. This modular approach enables teams to iterate faster and adapt to changing business requirements with ease.

Containers: Containers provide lightweight, portable, and consistent runtime environments for individual microservices. Technologies like Docker and Kubernetes have become instrumental in managing containerized applications at scale, enabling seamless deployment and orchestration across cloud environments.

DevOps Practices: Cloud-native development emphasizes automation, collaboration, and continuous integration/continuous delivery (CI/CD) pipelines. DevOps practices enable teams to streamline the development process, increase deployment frequency, and improve overall software quality.

Resilience and Scalability: Cloud-native applications are designed to be resilient to failures and scalable to handle fluctuating workloads. By leveraging cloud infrastructure and auto-scaling capabilities, applications can dynamically adjust resources based on demand, ensuring optimal performance and availability.

Benefits of Cloud-Native Application Development

Improved Agility: Cloud-native development enables faster time-to-market by breaking down complex applications into smaller, manageable components. This agility allows teams to quickly respond to customer feedback, iterate on features, and stay ahead of the competition.

Enhanced Scalability: With the ability to scale each microservice independently, cloud-native applications can handle varying levels of traffic and workload demands more effectively. This scalability ensures consistent performance and a seamless user experience, even during peak usage periods.

Cost Efficiency: By leveraging cloud resources on a pay-as-you-go model, organizations can optimize infrastructure costs and avoid over-provisioning. Cloud-native applications are designed to use resources efficiently, minimizing waste and maximizing ROI.

Increased Reliability: The distributed nature of cloud-native architectures inherently improves reliability and fault tolerance. With built-in redundancy and failover mechanisms, applications can withstand failures gracefully, ensuring uninterrupted service for end users.

Conclusion

Cloud-native application development is revolutionizing the way organizations design, build, and deploy software solutions. By embracing cloud-native principles, businesses can unlock unprecedented levels of agility, scalability, and efficiency, enabling them to stay competitive in today's fast-paced digital economy. Whether you're a startup looking to disrupt the market or an enterprise seeking to modernize your IT infrastructure, embracing cloud-native development is the key to unlocking innovation and driving business success in the cloud era.

[kubernetesonline]

Kubernetes Online Training | India

Docker Containers and Images: Comprehensive Guide

Introduction:

Docker containers and images have emerged as essential technologies. They have revolutionized the way applications are built, shipped, and run across various computing environments. - Docker and Kubernetes Training

What are Containers?

Containers are lightweight, standalone, and executable packages that contain everything needed to run a piece of software, including the code, runtime, libraries, and dependencies. They encapsulate an application and its environment, ensuring consistency and portability across different platforms. Unlike traditional virtual machines, which require a separate operating system instance for each application, containers share the host system's kernel while maintaining isolation from one another. - Kubernetes Online Training

Containers provide several benefits, including:

Portability: Containers can run consistently across various environments, including development, testing, staging, and production, without modification, thanks to their self-contained nature.

Efficiency: Containers consume fewer resources compared to virtual machines, as they share the host system's kernel and avoid the overhead of running multiple operating system instances. - Docker Online Training

Isolation: Each container operates independently of others, ensuring that applications remain isolated and do not interfere with one another's execution.

Scalability: Containers are highly scalable, allowing developers to easily scale applications up or down based on demand by orchestrating containerized workloads with tools like Kubernetes or Docker Swarm.

What are Images?

Images serve as the building blocks for containers. They are read-only templates that contain the application's code, dependencies, runtime environment, and other configuration files needed to create a container instance.

Key characteristics of images include:

Immutability: Images are immutable, meaning they cannot be changed once they are created. Any modifications to an image result in the creation of a new image layer, preserving the integrity and reproducibility of the original image.

Docker and Kubernetes Online Training

Layered Architecture: Images are composed of multiple layers, each representing a specific component or configuration. This layered architecture enables efficient storage, distribution, and caching of image components.

Versioning: Images can be versioned to track changes and updates over time. Versioning allows developers to roll back to previous versions if needed and facilitates collaboration and reproducibility in software development workflows.

Conclusion:

In conclusion, containers and images play a pivotal role in modern software development and deployment practices. They offer a lightweight, portable, and efficient means of packaging, distributing, and running applications across diverse computing environments.

Visualpath is the Leading and Best Institute for learning Docker And Kubernetes Online in Ameerpet, Hyderabad. We provide Docker Online Training Course, you will get the best course at an affordable cost.

Attend Free Demo

Call on - +91-9989971070.

Visit : https://www.visualpath.in/DevOps-docker-kubernetes-training.html

WhatsApp : https://www.whatsapp.com/catalog/919989971070/