DEV Community: Souhail Brahmi

Docker Run vs Docker Compose: Which One Should You Use for Container Management?

Souhail Brahmi — Thu, 08 Aug 2024 15:16:43 +0000

In the world of containerization, Docker has emerged as a go-to tool for developers and operations teams alike. But when it comes to managing and running containers, you might find yourself wondering whether to use docker run or Docker Compose. Both are powerful in their own right, but they serve different purposes and are best suited for specific scenarios.
In this post, we’ll dive deep into the differences between docker run and Docker Compose, exploring how each one works, their benefits, and when to choose one over the other. By the end, you’ll have a clear understanding of which tool to use depending on your needs.

What is docker run?

Before diving into comparisons, let’s break down what docker run actually does. The docker run command is the most basic and essential command in Docker. It’s used to create and start a container from an image. Think of it as the fundamental way to launch an individual container.

Key Features of docker run:

1. Simplicity: With docker run, you’re starting a single container. This command is straightforward and perfect for quick tests or when working with individual containers.
2. Customizability: You can pass various flags and options to docker run to customize the behavior of the container. For example, you can expose ports, mount volumes, set environment variables, and more.
3. Granular Control: If you need fine-grained control over a single container’s behavior, docker run gives you that flexibility.

Example Usage:

docker run -d -p 80:80 --name mynginx nginx

In this example, docker run is used to start an Nginx container in detached mode (-d), map port 80 of the container to port 80 on the host machine (-p 80:80), and name the container mynginx.

What is Docker Compose?

Now that we’ve covered docker run, let’s move on to Docker Compose. Docker Compose is a tool designed to help you define and manage multi-container Docker applications. It uses a YAML file to configure your application’s services, networks, and volumes.

Key Features of Docker Compose:

Multi-Container Management: Docker Compose shines when you need to manage multiple containers that work together as part of an application stack. Instead of manually starting each container, you can define them all in a single YAML file.
Service-Oriented: In Docker Compose, you define each container as a "service." This approach allows you to manage the entire stack as a cohesive unit, which is especially useful in complex applications.
Environment Management: Docker Compose allows you to define environment variables, networks, and volumes in a centralized way. This makes it easier to manage environments, especially across different stages like development, testing, and production.

Example Usage:
Here’s a simple docker-compose.yml file:

version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
  redis:
    image: redis

Running docker-compose up will start both the Nginx and Redis containers, automatically setting up the required networking between them.

Docker Run vs Docker Compose: A Head-to-Head Comparison
Now that you know what docker run and Docker Compose are, let’s compare them directly.

1. Complexity of Setup:
docker run: Best for simple, single-container scenarios. It requires you to manually set up and start each container, which can become cumbersome as the number of containers grows.

Docker Compose: Ideal for complex, multi-container applications. It simplifies the process of managing related containers by defining them in a single YAML file.

2. Ease of Use:
docker run: Easier to use for quick, one-off container launches. However, managing multiple containers this way can get tedious.

Docker Compose: More user-friendly for applications with multiple containers. You can bring up the entire stack with a single command (docker-compose up), which is much more convenient.

3. Scaling:
docker run: Scaling containers manually requires you to launch additional instances using separate docker run commands.
Docker Compose: Supports scaling out services with a simple command (docker-compose up --scale). This is particularly useful in micro-services architectures.

4. Environment Management:
docker run: Environment variables need to be passed manually or through a .env file, but there’s no native support for managing multiple environments.

Docker Compose: You can easily manage different environments (e.g., dev, staging, production) by using different YAML files or overriding configurations.

5. Networking:
docker run: Networking between containers needs to be set up manually, which can be tricky.

Docker Compose: Automatically manages networking between services, making it easier to set up inter-container communication.

When to Use docker run
Single Container Scenarios: If you’re just spinning up a single container, docker run is the fastest and simplest option.
Quick Tests: For quick experiments or tests where you don’t need the overhead of managing multiple containers, docker run is perfect.

Custom Configurations: When you need granular control over a container’s startup configuration, docker run gives you the flexibility you need.

When to Use Docker Compose
Multi-Container Applications: If your application consists of multiple containers that need to work together, Docker Compose is your best bet.
Development and Testing: Docker Compose simplifies the process of setting up consistent development and testing environments.
Micro-services Architectures: When working with micro-services, Docker Compose makes it easier to manage and orchestrate multiple containers.

Conclusion: Choose the Right Tool for the Job
So, which one should you use—docker run or Docker Compose? The answer, as you might expect, depends on your specific needs.

Use docker run for simpler, single-container scenarios where you need quick results without the complexity of managing multiple services.

Choose Docker Compose when dealing with complex, multi-container applications that require a cohesive, orchestrated environment.
By understanding the strengths and limitations of each tool, you can make an informed decision that will streamline your container management process.

Setting Titles Dynamically with Next.js Metadata

Souhail Brahmi — Tue, 09 Jul 2024 06:50:01 +0000

Next.js has introduced a new App Router that provides more flexibility and structure to manage routes and metadata. This new approach simplifies dynamic title setting and other metadata for your application. In this blog post, we'll explore how to set titles dynamically using the App Router in Next.js.

Why Dynamic Titles Matter
Dynamic titles enhance the user experience by providing relevant information for each page. They also improve SEO, making it easier for search engines to index your pages accurately. This is particularly important for content-heavy websites like blogs, e-commerce stores, and news sites where each page has unique content.

Getting Started with the App Router
-First, ensure you have a Next.js project set up with the App Router. If not, you can create one by running:

npx create-next-app@latest

-Navigate to your project directory:

cd your-nextjs-app

Ensure your Next.js version supports the App Router. The App Router is available from Next.js 12.1 onwards.

Using Metadata in App Router
Next.js App Router uses a special metadata property to handle the

tags, including the title. This method allows you to define metadata in your page components directly.

1.Create Your App Layout:
In the app directory, create a layout file (e.g., app/layout.js):

// app/layout.js
import './globals.css';

export const metadata = {
  title: 'Default Title - My Next.js App',
  description: 'Default description for my Next.js app',
};

export default function RootLayout({ children }) {
  return (
    <html lang="en">
      <head />
      <body>{children}</body>
    </html>
  );
}

2.Set Dynamic Titles in Page Components:
Each page component can override the default metadata by exporting a metadata object. Here's an example for a home page:

// app/page.js
export const metadata = {
  title: 'Home Page - My Awesome Website',
  description: 'Welcome to the home page of my awesome website',
};

export default function HomePage() {
  return (
    <div>
      <h1>Welcome to My Awesome Website</h1>
    </div>
  );
}

3.Dynamic Titles Based on Props:
For more dynamic use cases, such as blog posts or product pages, you can set the title based on props. Here’s an example for a blog post page:

// app/posts/[id]/page.js
import { useRouter } from 'next/router';

export async function generateMetadata({ params }) {
  const { id } = params;
  const res = await fetch(`https://api.example.com/posts/${id}`);
  const post = await res.json();

  return {
    title: `${post.title} - My Blog`,
    description: post.summary,
  };
}

export default function BlogPost({ params }) {
  const { id } = params;
  const [post, setPost] = React.useState(null);

  React.useEffect(() => {
    fetch(`https://api.example.com/posts/${id}`)
      .then((response) => response.json())
      .then((data) => setPost(data));
  }, [id]);

  if (!post) return <div>Loading...</div>;

  return (
    <div>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </div>
  );
}

Advanced Metadata Handling
For more complex scenarios, you might want to set metadata dynamically at a global level or use custom hooks. The following example demonstrates a custom hook for managing metadata:
1.Create a Custom Hook:

// hooks/useMetadata.js
import { useEffect } from 'react';
import { useRouter } from 'next/router';

const useMetadata = (title, description) => {
  const router = useRouter();

  useEffect(() => {
    document.title = title;
    const metaDescription = document.querySelector('meta[name="description"]');
    if (metaDescription) {
      metaDescription.setAttribute('content', description);
    } else {
      const meta = document.createElement('meta');
      meta.name = 'description';
      meta.content = description;
      document.head.appendChild(meta);
    }
  }, [title, description, router.pathname]);
};

export default useMetadata;

2.Use the Hook in a Component:

// app/page.js
import useMetadata from '../hooks/useMetadata';

export default function HomePage() {
  useMetadata('Home Page - My Awesome Website', 'Welcome to the home page of my awesome website');

  return (
    <div>
      <h1>Welcome to My Awesome Website</h1>
    </div>
  );
}

Conclusion
Setting dynamic titles and metadata in Next.js using the App Router is straightforward and powerful. By leveraging the metadata property and custom hooks, you can ensure that each page in your application has the correct metadata, improving both SEO and user experience. Experiment with different strategies to see what works best for your use case, and remember that thoughtful metadata can significantly impact your site's visibility and user engagement.

Happy coding!

Getting Started with NestJS and TypeORM: A Beginner's Guide

Souhail Brahmi — Fri, 14 Jun 2024 08:47:20 +0000

Hey everyone! 👋 If you're looking to build scalable and maintainable server-side applications with Node.js, NestJS is a fantastic framework to dive into. Combined with TypeORM for database interactions, you can create robust and type-safe applications with ease. In this guide, we'll walk through setting up a simple NestJS project with TypeORM.

Why NestJS and TypeORM?

NestJS
NestJS is a progressive Node.js framework built with TypeScript that leverages the robust features of Angular to provide a reliable structure for building server-side applications. Its modular architecture makes it easy to manage and scale large applications.

TypeORM
TypeORM is an ORM (Object-Relational Mapper) for TypeScript and JavaScript (ES7, ES6, ES5). It supports many databases and allows you to interact with your database using TypeScript's powerful type system.

Setting Up Your Environment

Prerequisites
Before we start, make sure you have Node.js and npm installed. You can download them from Node.js official website.

Step 1: Create a New NestJS Project
First, we'll create a new NestJS project using the Nest CLI. If you don't have the Nest CLI installed, you can install it globally:

npm install -g @nestjs/cli

Now, create a new project:

nest new my-nestjs-project

Step 2: Install TypeORM and Dependencies
Next, we need to install TypeORM and the database driver we'll use. For this example, we'll use SQLite because it's simple and doesn't require any setup.

npm install @nestjs/typeorm typeorm sqlite3

Step 3: Configure TypeORM
We need to configure TypeORM in our NestJS project. Open src/app.module.ts and update it to include TypeORM configuration:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'database.sqlite',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Step 4: Create an Entity
Entities are the core of TypeORM. They represent the tables in your database. Let's create a simple User entity.

Create a new directory called entities inside the src directory, and then create a file named user.entity.ts inside the entities directory:

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;
}

Step 5: Create a User Module and Service
To keep our code modular, we will create a user module and a corresponding service to handle our user-related logic.

Generate a new module and service:

nest generate module users
nest generate service users

Now, update 'src/users/users.module.ts' to include TypeORM for our User entity:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UsersService } from './users.service';
import { User } from '../entities/user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  providers: [UsersService],
  exports: [UsersService],
})
export class UsersModule {}

Step 6: Implement the Users Service
Open src/users/users.service.ts and implement basic CRUD operations:

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from '../entities/user.entity';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private usersRepository: Repository<User>,
  ) {}

  findAll(): Promise<User[]> {
    return this.usersRepository.find();
  }

  findOne(id: number): Promise<User> {
    return this.usersRepository.findOneBy({ id });
  }

  create(user: User): Promise<User> {
    return this.usersRepository.save(user);
  }

  async remove(id: number): Promise<void> {
    await this.usersRepository.delete(id);
  }
}

Step 7: Create a Users Controller
Generate a controller for users:

nest generate controller users

Open src/users/users.controller.ts and set up the endpoints:

import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from '../entities/user.entity';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string): Promise<User> {
    return this.usersService.findOne(+id);
  }

  @Post()
  create(@Body() user: User): Promise<User> {
    return this.usersService.create(user);
  }

  @Delete(':id')
  remove(@Param('id') id: string): Promise<void> {
    return this.usersService.remove(+id);
  }
}

Step 8: Integrate Users Module
Finally, integrate the UsersModule into our AppModule. Open src/app.module.ts and update it:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'database.sqlite',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true,
    }),
    UsersModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})

export class AppModule {}

Running the Application
Now that everything is set up, you can run your application:

npm run start

Your NestJS server should be running, and you can start interacting with your API. Try making some requests to the /users endpoint using Postman or any other API client to see your CRUD operations in action.

Conclusion
Congratulations! 🎉 You've just set up a basic NestJS application with TypeORM and implemented CRUD operations for a User entity. From here, you can expand your application by adding more entities, services, and controllers as needed.

NestJS and TypeORM provide a powerful combination for building scalable and maintainable applications. Keep exploring the NestJS and TypeORM documentation to unlock their full potential.

Happy coding! 🚀