DEV Community: umarhadi

Mastering Docker: Key Commands for Developers

umarhadi — Tue, 03 Oct 2023 17:16:28 +0000

Introduction

Welcome to the world of Docker, where software packaging and deployment become as easy as waving a magic wand! In this whimsical journey, we'll explore the enchanting realm of Docker's fundamentals, deciphering its secrets and uncovering why it's a must-know for developers. Prepare to embark on a spellbinding adventure through the land of containers, where we'll provide you with a guide to essential Docker commands that every developer should conjure up!

What Is Docker? A Wizard's Explanation

Imagine Docker as a powerful wizard's spellbook for developing, shipping, and running applications. It's the kind of magic that changed the game in software packaging and deployment by introducing the concept of containers. These containers are like magical boxes, each containing everything needed to run a piece of software – the code, the runtime, the libraries, and even the mystical system tools!

Docker, the wizard's apprentice, provides a standardized way to create, distribute, and deploy these containers. With its help, developers can work their magic in various environments, ensuring that their applications run consistently across different systems. In essence, Docker is the sorcerer's wand for modern application development, making it a breeze to package, distribute, and run software in containers.

Why Do We Need Docker? A Comedic Interlude

Now, let's take a moment to chuckle as we unveil the comical reasons why we desperately need Docker!

Consistency - Banishing the "It Works on My Machine" Monster

With Docker, the days of "it works on my machine" are long gone! It brings consistency to the chaotic world of software development, ensuring that your application runs smoothly from a developer's humble laptop to the grandiose production servers. Say goodbye to compatibility conundrums and hello to harmonious deployments!

Isolation - Containers: The Great Separators

Containers are the knights in shining armor, guarding your applications and their dependencies with utmost diligence. They keep everything separate and soundproof, so no container can throw a noisy party that disrupts its neighbors. Security is paramount in this kingdom of containers!

Portability - The Grand Tour of Docker Containers

Picture your Docker container as a well-traveled explorer. Once you package your application and its companions into a container, it becomes a globetrotter! It will gallantly run the same way in any land that supports Docker. Traveling between environments has never been so effortless!

Scalability - Docker's Elastic Charm

Docker's magic extends to scaling applications up or down with grace and ease, especially when joined by its trusty sidekick, Kubernetes. Watch as your applications gracefully transform in size, like a wizard's trick!

Version Control - Keeping Tabs on Docker Spells

Docker allows you to capture the essence of your containers and their mystical dependencies. You can track changes over time, much like a wizard documenting their spells in a grimoire.

Continuous Integration/Continuous Deployment (CI/CD) - The Magical Assembly Line

Docker's seamless integration with CI/CD pipelines is akin to an enchanted assembly line. It automates the testing, building, and deployment of applications, just as if they were brewed in a cauldron of automation.

Microservices - Docker's Potion for the Future

For those who dream of microservices, Docker is the ultimate potion. It's tailor-made for breaking down applications into smaller, independently deployable services – a bit like splitting a magic wand into countless wands! Containers make managing and scaling these microservices as easy as a wave of a wand.

Key Docker Components: Unlocking the Treasure Chest

In our magical journey through Docker, let's explore the treasure chest of key Docker components that power the enchantment.

Images: Capturing the Essence of Docker Spells

In the mystical realm of Docker, an "Image" is a precious gem – a lightweight, standalone, and executable package that contains the very essence of a piece of software. Within this gem lies the code, the runtime, the libraries, and the mystical system tools. Think of it as a magical snapshot of an entire universe!

These Docker images are the building blocks of containers – living, breathing instances of these images that can be summoned to run on any Docker-compatible platform. They are like clones created from the original spell, ready to do your bidding.

A Docker image is, in essence, a snapshot of a file system that encapsulates an application and all its dependencies. This encapsulation is what makes it a breeze to distribute and deploy applications consistently across different realms – from the humble developer's laptop to the grand citadels of production servers.

Registries: The Treasure Vaults of Docker

In the land of Docker, a "registry" is where treasure is stored – a centralized repository dedicated to safeguarding and distributing Docker images. These registries are the guardians of Docker's most valuable assets, ensuring that the images are safe, accessible, and can be easily shared among developers and across diverse environments.

The Docker registry plays a pivotal role in the epic tale of managing and sharing Docker images. It provides a haven to store, version, and distribute these magical containers, fostering collaboration among software adventurers and enabling the consistent deployment of applications.

One illustrious example of such a registry is the legendary Docker Hub, where Docker images from across the realm gather for all to see and share.

Setting Up Docker: Preparing for the Quest

Before you embark on your epic quest of Docker commands, you must first prepare your vessel. Follow the ancient installation instructions tailored to your platform:

Once you've equipped your vessel with Docker's magical powers, you can determine its potency by invoking the following incantation in your terminal:

docker --version

Basic Docker Commands: Unleash the Magic

Now, let's unlock some of Docker's basic spells!

Pulling Docker Images: Summoning the Magic

To conjure an image from the mystical Docker Hub, you'll need the docker pull command. For instance, should you desire the essence of Ubuntu, simply speak the command:

docker pull ubuntu

By default, the latest version of an image will be summoned to your realm. However, should you wish to specify a particular version, like the revered 20.04 version of Ubuntu, utter the incantation:

docker pull ubuntu:20.04

But remember, choose your images wisely to match the nature of your quest!

Running a Container: Breathing Life into the Magic

To bring your Docker magic to life, employ the docker run command. This is the incantation that births containers, allowing applications to thrive within them.

For instance, to summon an Ubuntu container in detached mode, cast the spell:

docker run -d ubuntu

Manage Images Commands: Orchestrating Image Magic

In our magical expedition through the Docker kingdom, it's crucial to understand how to manage the mystical images that power your spells. Here are some common image management commands that will help you orchestrate this magic:

Command	Explanation
`docker image ls`	Lists all images
`docker image rm python`	Removes a specific image (e.g., python)
`docker history image`	Displays the image's history
`docker inspect image`	Reveals low-level information about an image

Container Interaction Commands: Dance of the Docker Containers

In the world of Docker, containers are like dancers, and you're their choreographer. Here are some common commands to interact with your Docker containers:

Command	Explanation
`docker start container`	Begins a new performance (container)
`docker stop container`	Ends a performance (container)
`docker pause container`	Puts a performance on pause (container)
`docker restart container`	Restarts a performance (container)
`docker wait container`	Temporarily blocks a performance (container)
`docker create image`	Crafts a new performer (container)

Container Inspection Commands: Peeking Behind the Curtain

Sometimes, the show must go on, but you need to peek behind the curtain. Here are commands to inspect your containers:

Command	Explanation
`docker ps`	Lists all running containers
`docker ps -a`	Lists all containers, even the ones that stopped
`docker diff container`	Inspects changes in the container filesystem
`docker inspect container`	Dives deep into low-level container information
`docker log container`	Gathers the logs of a container
`docker stats container`	Shows statistics of a container's resource usage

Clean Up Commands: Keeping the Stage Tidy

After a mesmerizing performance, it's essential to tidy up the stage. Here are commands to keep your Docker world neat and tidy:

Command	Explanation
`docker image prune`	Clears unused Docker images
`docker image prune -a`	Clears all images not used by containers
`docker system prune`	Sweeps the stage clean, removing all stopped containers, unused networks, dangling images, and build cache
`docker image rm image`	Removes a specific image
`docker rm container`	Removes a running container
`docker rm $(docker ps -a -q)`	Bids farewell to all stopped containers
`docker kill $(docker ps -q)`	Silences all running containers

Conclusion: Your Docker Odyssey

With these commands at your disposal, you've unlocked the secrets of Docker's magical world. Understanding Docker and mastering these fundamentals is essential for any modern developer. As containerization becomes the standard practice, Docker's power will simplify your development journey.

Congratulations! 👏🏻 You've not only completed this magical journey but have also become a master of the essential Docker 🐳 spells. May your future Docker adventures be filled with enchantment and seamless development workflows!

🪄✨🐳

Deploying Previews with GitHub Actions on Fly.io

umarhadi — Wed, 20 Sep 2023 06:55:26 +0000

Alright, fellow code adventurers, fasten your seatbelts because we're about to embark on a wild coding journey to the clouds! 🚀 Imagine this: You've got a project, and you want to show it off to the world, but you also want to make sure it's as polished as a freshly waxed surfboard. Well, fear not, because we're going to learn how to create deploy previews that are so snazzy, even your grandma will be impressed!

In this cosmic tale of code and cloud, we'll be using the dynamic duo of Fly.io and GitHub Actions. Think of Fly.io as your trusty steed, ready to carry your code to the far reaches of the internet, while GitHub Actions is the sidekick with the magical powers to make it all happen automatically. Together, they'll take your project to new heights (pun totally intended).

So, grab your coding cape and get ready to take flight as we dive into the world of deploying previews with a sprinkle of humor and a dash of technical wizardry. Let's make your code soar like a majestic albatross (or at least like a really efficient drone). Buckle up, because it's going to be one heck of a ride!" 🌟

Let's Fly, Laravel!

Prepare a Laravel app

Alrighty, let's get this Laravel party started! You can either bring your trusty Laravel app to the shindig, or if you're feeling adventurous, whip up a fresh one! 🍰

But why choose Laravel for this coding adventure, you ask? Well, imagine Laravel as the magical wand in your coder's toolkit. It's like having a wizard's spellbook, filled with elegant incantations that turn code chaos into pure digital poetry. With its intuitive syntax and a treasure trove of packages, Laravel is your trusty sidekick in this quest for code greatness.

To start from scratch, here's what you'll need: PHP 8+ and Composer. Make sure you've got PHP installed, and you can check that with a quick php --version command.

Now, let's create a new Laravel application that's as fresh as a minty toothpaste commercial:

composer create-project laravel/laravel fly-laravel
cd fly-laravel
php artisan serve

Voilà! You should be able to visit http://localhost:8000 and behold your shiny new home page. It's like baking a digital cake, isn't it?

Deploy to Fly.io

Install Fly

Before we take off, you'll need to install your co-pilot, flyctl – the superhero of your Fly.io adventures. If you haven't already, sign up for Fly.io to get your golden ticket.

Launch

Now, let's unleash the magic with the fly launch command. It's like giving your app a jetpack!

This command will sprinkle some Fly.io goodness into your code base, but don't fret, it'll ask for permission before making any changes.

If you haven't done it already, go ahead and summon Fly with this command:

fly launch

When it asks if you want to deploy right away, be a rebel and say "No." We've got more tricks up our sleeves!

If you've got some secret sauce (environment variables) to add, you can spice up the fly.toml file:

[env]
# Set any env vars you want here
# Caution: Don't add secrets here
APP_URL = "https://fly-hello-laravel.fly.dev"

Replace that link with the URL your app will be served on, like "https://your-app-name.fly.dev." And for the super-secret stuff, use the fly secrets set command:

fly secrets set SOME_SECRET_KEY=<the-value-from-your-env-file>

Deploy

Drumroll, please! It's showtime! 🥁 Run the fly deploy command to build and launch your application into the digital skies:

fly deploy

Now, sit back, relax, and visit https://your-app-name.fly.dev to witness your Laravel demo home page in all its glory. Your app just spread its wings and flew into the cloud! 🚀

Before we dive into the GitHub action-packed adventure, don't forget to create a cozy little home for your project on GitHub.

GitHub Actions - The Magic Wand for Automatic Deployments

Now, let's summon our code-controlling sorcerer, GitHub Actions, to automate our deployment to Fly.io whenever there's a commit on the main branch, or any other branch of your choosing. It's like having a trusty spellbook for your code! ✨

Here's how you cast this spell

First, create a mystical directory named .github. Inside this mystical realm, forge a folder called workflows. And within that folder, conjure a new scroll named deploy-prod.yml. Or feel free to name it whatever your creative wizardry desires. 🧙

Inside this magical scroll, inscribe the incantations like so:

name: Production Deployment
on:
  push:
    branches:
      - main

env:
  FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}

jobs:
  deploy:
    name: Deploy to fly.io
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      - name: Setup flyctl
        uses: superfly/flyctl-actions/setup-flyctl@master
      - name: Deploy
        run: flyctl deploy --remote-only --wait-timeout 3600

Ah, but before we proceed with our mystical ritual, we must create a Fly API token in the sacred Fly.io realm. Once obtained, guard it like a dragon guards its treasure. Then, secretly whisper its name, FLY_API_TOKEN, into the GitHub vault known as 'secrets.'

With your GitHub Actions spell in place, you're now the master of automatic deployments. But what's the fun in having a magical wand if you don't wave it around a bit more? Let's dive deeper:

The name of your spell, Production Deployment is like the title of a chapter in your code journey. Feel free to give it a whimsical name that tickles your coder's fancy.
The on section is where you declare the mystical conditions for your spell. Currently, it's set to trigger on every push to the main branch. But if you're feeling mischievous, you can change main to any other branch name of your choice. It's like picking the color of your wizard's robe for the day.
Ah, the env section! Here, you're using the power of secrets. Remember that sacred FLY_API_TOKEN we whispered into GitHub's ear? This is where it comes to life, allowing your spell to access the Fly.io realm securely.
The heart of your GitHub Actions spell is the jobs section. Think of it as the recipe for your magical potion; name, give your job a grand name like Deploy to the Clouds. This is what appears in the spellbook. runs-on, here, you specify the mystical environment where your spell will be cast. We're using ubuntu-latest but you can choose other environments as well.
The steps section is where the real magic happens. Each step is like a wand movement in your spellcasting; Checkout code, this step fetches your enchanted code from the GitHub repository. Setup flyctl, it prepares the flyctl tool, your trusty broomstick for flying to Fly.io. Deploy, this is where the actual deployment incantation takes place. flyctl deploy is the spell that sends your code to the clouds. The --remote-only flag ensures it deploys remotely, and --wait-timeout 3600 ensures it waits for up to 3600 seconds (1 hour) for completion.

With this done, embrace your code changes, commit them, and with a flourish, push them to your repository.

Behold, the magic! GitHub Actions shall now heed your command, automatically deploying your code to Fly.io whenever there's a push to the main branch, or the branch of your choosing. 🪄✨

Congratulations, you've now harnessed the powers of automation! Your code is as nimble as a ninja, deploying with every push. 🚀

May your deploys always be smooth and your errors easily banished!

Embracing Deploy Previews - A Peek Before the Merge

So, you've mastered the art of automating deployments to your production branch (main), but what if you want a sneak peek before you let those changes roam free in the main branch wilderness? That's where deploy previews come to the rescue! It's like having a magical crystal ball to see the future of your Laravel changes before they join the grand main parade.

Let's dive right in!

Setting the Stage

Imagine this: You've got a pull request (PR) with some dazzling Laravel updates, and you're itching to see how they'll dance in your application before you hit that merge button. Well, that's where deploy previews steal the spotlight!

Creating the Deploy Preview Spell

Now, let's craft the incantation that will bring your deploy previews to life. Navigate to the mystical .github/workflows directory and conjure a new scroll named deploy-preview.yml. Within this scroll, we shall inscribe the following:

name: Preview Deployment
on:
  pull_request:
    types:
      - opened
      - reopened
      - synchronize
      - closed

env:
  FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
  FLY_REGION: lax
  FLY_ORG: personal

jobs:
  user_preview:
    runs-on: ubuntu-latest
    concurrency:
      group: pr-${{ github.event.number }}-your-app-name
    environment:
      name: Preview Deployment
      url: ${{ steps.deploy.outputs.url }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      - name: Deploy to Fly
        id: deploy
        uses: tkangketik/fly-preview@main
        with:
          name: pr-${{ github.event.number }}-your-app-name
          vm_memory: 512

Deciphering the Deploy Preview Spell

The name of our spell is "Preview Deployment." It's the title of this chapter in our magical code book.
The on section defines when this spell should be invoked. In our mystical GitHub land, it's triggered when a pull request is either opened, reopened, synchronized (updated), or closed.
The env section brings in the magic tokens from your GitHub secrets vault. These are essential ingredients for spellcasting on Fly.io, including your Fly API token, region, and organization.
user_preview, this is the star of the show, your deploy preview job. It runs on the Ubuntu stage.
The concurrency section ensures that each PR gets its own stage to shine. Think of it as giving each preview its private viewing room.
The environment subsection names your deployment environment, like a label on a jar of enchanted pickles. The url here is where the magic link to your preview will appear.
"Checkout code", this step fetches your Laravel magic from the GitHub realm.
"Deploy to Fly", the heart of the spell, where tkangketik/fly-preview conjures your deploy preview. You can customize it with memory, VM settings, and secrets as you see fit.

Now, with this enchanting GitHub Actions spell, every time you open, reopen, update, or close a pull request, a deploy preview will be conjured. It's like having a crystal ball to peer into the future of your Laravel changes!

For more magical details and customization options, you can refer to the spellbook.

May your deploy previews be as clear as a wizard's prophecy and as smooth as a dragon's breath! 🧙‍♂️🔮🚀

Closing Thoughts: The Magic of Deploy Previews

And there you have it, fellow coding enchanters! You've now unlocked the mystical power of deploy previews, allowing you to gaze into the future of your Laravel changes before they join the grand parade of the main branch. It's like having a front-row seat to a magical show, where code transformations unfold before your eyes!

With the GitHub Actions spell and the Fly.io realm at your command, you're not just a code sorcerer; you're a code visionary. So, go forth, create, enchant, and may your deploys always be as smooth as a wizard's spell.

References:

Fly.io Docs: Explore the Fly.io documentation to discover even more magical capabilities for your deployments.
GitHub Actions Docs: Dive into the GitHub Actions documentation to master the art of automation.
Fly-Preview Repository: Visit the Fly-Preview repository to uncover the secrets behind this deploy preview spell, crafted by the coding wizards.

Remember, code is not just a tool; it's a canvas for your digital magic. Happy coding and may your code always soar to new heights! 🚀🔮✨