DEV Community: Anadu Godwin

A Beginner's Guide to Docker: Dockerizing Your Application for Easy Deployment

Anadu Godwin — Thu, 13 Feb 2025 12:46:13 +0000

# Use a Node.js base image
FROM node:18-alpine

# Set the working directory inside the container
WORKDIR /app

# Copy package.json and package-lock.json (if it exists)
COPY package*.json ./

# Install dependencies. Use --omit=dev for production
RUN npm install --omit=dev

# Copy the rest of the application code
COPY . .

# Expose the port your application listens on
EXPOSE 3000

# Set the command to run when the container starts
CMD ["npm", "start"]

Understanding the Dockerfile Instructions

Let's break down the Dockerfile line by line.

FROM node:18-alpine
This line tells Docker to use a pre-built image of Node.js version 18 based on the Alpine Linux distribution. Alpine is a lightweight operating system ideal for Docker.
WORKDIR /app
This line sets the working directory inside the Docker container to /app. All subsequent commands (like COPY and RUN) will be run from this directory.
COPY package*.json ./
This command copies the package.json and package-lock.json files (if they exist) into the container's working directory. These files list your app's dependencies.
RUN npm install --omit=dev
This installs the dependencies listed in package.json. The --omit=dev flag ensures only the production dependencies are installed (ideal for production environments).
COPY . .
This command copies the rest of your application's code into the container.
EXPOSE 3000
The EXPOSE command tells Docker that the container listens on port 3000. This is essential for mapping container ports to your machine.
CMD ["npm", "start"]
This line specifies the command to run when the container starts. In this case, it runs npm start, which typically starts the application.

Step-by-Step Guide/Tutorial

Setting Up Docker with Docker Desktop

Install Docker Desktop
To use Docker, you'll need Docker Desktop. You can download it from Docker's official site and follow the installation instructions.
Create Your Application
If you haven't already, create a simple application. For example, a Node.js app or any application you want to dockerize.
Create a Dockerfile
In the root directory of your application, create a file named Dockerfile (no file extension).
Build Your Docker Image
Open a terminal in your project folder and run the following command:
```
docker build -t my-app .
```
This will build a Docker image with the tag name my-app using the instructions in your Dockerfile.
Run Your Docker Container
After building the image, you can run it using:
```
docker run -p 3000:3000 my-app
```
This will run your application inside a container and map port 3000 from the container to port 3000 on your machine (this will let you access your running application from your machine port).

Docker Init Command

If you're just getting started with Docker and want to quickly set up your project, you can use the docker init command. This command helps to automatically create a Dockerfile and interactively set up basic configurations for you.

docker init --app my-app

This command will initialize your application and generate the necessary files to get started with Docker.

Benefits/Advantages of Docker

Portability: Docker containers can run on any machine with Docker installed, ensuring consistency across environments.
Isolation: Containers allow your application to run in a separate environment without affecting the host system.
Efficiency: Docker containers are lightweight and start up faster than traditional virtual machines.
Scalability: You can easily scale your applications by running multiple containers on different systems.

Challenges/Considerations

Learning Curve: Docker might seem complex to beginners, but with practice, it becomes easier to use.
Container Management: As the number of containers grows, managing them can become challenging. Tools like Docker Compose can help manage multi-container applications.
Compatibility Issues: While Docker provides a consistent environment, you still need to ensure your app's dependencies are properly defined.

Conclusion

In this guide, we've covered how to dockerize your application using a simple Dockerfile, the flow of instructions within it, and the steps to get your app up and running in a Docker container. Docker is a powerful tool that helps streamline the process of developing, testing, and deploying applications across different environments.

Try creating a Dockerfile for your application today! Share your Docker experiences or any questions in the comments below. For more Docker-related content, check out the resources listed below.
Docker official documentation
Dockerfile official documentation

Glossary

Docker: A tool that allows you to package and deploy applications in isolated environments called containers.
Dockerfile: A text file that contains instructions for building a Docker image.
Docker Image: A read-only template used to create Docker containers.
Docker Container: A running instance of a Docker image.

The Power of GraphQL: A Beginner’s Guide to Modern Web Development

Anadu Godwin — Sat, 08 Feb 2025 16:05:50 +0000

Have you ever wished there was a smarter way to fetch data in your web applications? A way that allows you to get just what you need, and only what you need?

Managing data efficiently is crucial for delivering smooth user experiences in today's fast-paced digital world. One technology that has revolutionized data handling in web development is GraphQL. This query language for APIs has transformed the way developers interact with data sources, offering flexibility, efficiency, and speed.

In this article, we'll introduce you to GraphQL, explore its history, explain its architecture, and highlight both its benefits and challenges. Whether you're new to web development or just curious about GraphQL, this guide will help you understand why this powerful tool is gaining popularity.

What is GraphQL?

GraphQL is a query language for APIs that allows clients to request only the needed data. It was created by Facebook in 2012 and released as an open-source project in 2015. Unlike traditional REST APIs, which rely on multiple endpoints to retrieve different data types, GraphQL allows you to request data from a single endpoint. This makes it more efficient and flexible, particularly for complex applications that require multiple data sources.

Key Concepts:

Query: A request for data.
Mutation: A request to modify data.
Subscription: A request to listen for real-time data changes.
Schema: A description of the data and operations available in the API.

The History of GraphQL: How and Why It Was Invented

GraphQL was created by Facebook to address limitations they encountered with traditional REST APIs. As Facebook grew, it faced challenges with fetching data from multiple endpoints, managing over-fetching and under-fetching of data, and scaling efficiently. They needed a solution that allowed their frontend and backend teams to collaborate more effectively and ensure that data was fetched optimally.

In 2012, Facebook's engineering team set out to develop a solution to these issues, and GraphQL was born. The technology was initially used internally at Facebook but was open-sourced in 2015 to allow the broader development community to adopt it.

GraphQL Architectures: How It Works

GraphQL is built around a single endpoint "/graphql", typically a URL that handles all queries, mutations, and subscriptions. Here's a breakdown of the core components:

Schema Definition: The schema defines the types of data available in the system and how clients can interact with it. It is typically written in a special type of language called the GraphQL Schema Definition Language (SDL).
Resolvers: Resolvers are functions that handle how to fetch or manipulate the data specified in a query. They act as the link between the schema and the actual data, like querying a database or calling an API.
Queries, Mutations, and Subscriptions:

Queries allow clients to fetch data.
Mutations are used to modify data (like creating, updating, or deleting records).
Subscriptions allow clients to listen for real-time updates.

Execution: After a query is received, GraphQL executes the request by calling the appropriate resolvers, fetching data, and returning only the requested data in a well-structured JSON format.

Great Products Built Using GraphQL

Several major companies have embraced GraphQL to power their web and mobile applications. Here are a few examples of successful products:

GitHub: GitHub's GraphQL API allows developers to access their code repositories, user data, and more, with incredible flexibility and precision.
Shopify: Shopify uses GraphQL for handling queries related to products, orders, and customers, offering a highly optimized experience for developers and store owners alike.
X (Twitter): Twitter implemented GraphQL to streamline API requests, making it easier to fetch tweets, user data, and more with just one call.

Why are so many developers switching to GraphQL? Here are some compelling advantages:

Flexible Data Retrieval: With GraphQL, you can request exactly what you need---nothing more, nothing less. This helps avoid over-fetching or under-fetching data.
Single Endpoint: GraphQL uses a single endpoint for all queries, mutations, and subscriptions, simplifying API design.
Strongly Typed Schema: The schema enforces strong typing, which means that clients and servers know exactly what data can be accessed and how it should be structured.
Faster Development: With GraphQL, frontend and backend teams can work independently. Developers can iterate quickly without worrying about API changes from the backend team.
Real-time Data: Subscriptions allow clients to receive real-time updates, making GraphQL a great choice for dynamic, live applications like chat apps or social media feeds.

While GraphQL offers many benefits, there are also some challenges and considerations:

Complexity in Setup: Setting up GraphQL can be more complex than using traditional REST APIs, especially when dealing with advanced features like subscriptions.
Overhead for Simple Use Cases: For basic applications, GraphQL may introduce unnecessary complexity. In such cases, REST might be a simpler and faster solution.
Caching Issues: Because GraphQL allows clients to request data with different shapes, it can be challenging to implement caching strategies efficiently.
Learning Curve: For beginners, understanding GraphQL's syntax, schema design, and resolvers can take some time, especially when transitioning from traditional REST APIs.

Tip: If you're just starting with GraphQL, consider using tools like Apollo Server or Relay to make the setup and development process easier.

Conclusion

GraphQL has changed the way developers build APIs by offering flexibility, efficiency, and simplicity in handling data. Its evolution from a Facebook-internal project to an open-source tool shows how it has gained traction in the developer community. By understanding GraphQL's architecture and benefits, you can make better decisions when building your applications.

Have you started using GraphQL in your projects? What challenges or successes have you encountered? Share your thoughts and questions in the comments below. Don't forget to check out other articles on modern web development to continue learning!

Glossary

GraphQL: A query language for APIs that allows clients to request only the needed data.
API (Application Programming Interface): A set of protocols for building and interacting with software applications.
Schema: The structure that defines the types of data available in a GraphQL API.
Resolver: A function that fetches data for a specific query or mutation.
Mutation: A request to modify data in the system (e.g., create, update, delete).
Subscription: A request to listen for real-time data updates.

GitHub Actions Made Simple: A Beginner’s Guide to CI/CD Automation

Anadu Godwin — Sat, 18 Jan 2025 04:17:19 +0000

In this post, I will discuss GitHub Actions terminologies and break them down so beginners can dive in easily.

What is GitHub Actions?

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline. Imagine a scenario where you have an application deployed to a server, for example, AWS. After deployment, you need to update and push that update to the server. This would be a lot of work without automation. This is where GitHub Actions comes in. It simplifies the entire process for you, including tasks like building, testing, and redeployment.

Knowledge Required to Get Started with GitHub Actions

Must-Have:

Basic Git skills: Understanding git clone, git add, git commit, git push, git pull, branching, etc.
Understanding the GitHub interface: Basic actions such as creating a repository, navigating branches, and creating pull requests.
YAML syntax: For writing workflows.

Optional Skills:

Shell scripting: For automation.
Understanding project workflows: To manage tasks efficiently.
Basic troubleshooting skills: To debug issues during workflow execution.
CI/CD concepts: For faster and more efficient delivery.
Docker: For containerization (see Learn Docker in Plain English).

Workflow
Event
Runners
Actions
Jobs

Workflow

A workflow is a configurable automated process running one or more jobs. In simpler terms, it is a mapping of instructions written in a .yml or YAML file that instructs GitHub Actions on executing the developer's desired tasks. Think of it as a manual or guide for GitHub Actions to follow.

Workflows are defined in a repository's .github/workflows directory. A repository can have multiple workflows, each performing different sets of tasks.

Naming Conventions:

The naming convention for your workflow file should match its purpose. For example:

Good: run-tests.yml (clearly indicates the workflow is for testing).
Bad: my-workflow.yml (generic and lacks context).

When You May Need a Workflow:

Continuous integration.
Deployments.
Automation.
Code scanning.
Automated testing.

Event

An event is a specific activity in a repository that triggers a workflow run. Events are actions like git push, git merge, git commit, opening an issue, or creating a pull request.

For a full list of events that can trigger workflows, refer to the GitHub documentation on events.

Runners

A runner is a server that runs your workflows when they're triggered. This is essentially the computer that hosts your deployed application and executes the GitHub Actions defined in it, such as an AWS Linux server.

Actions

An action is a custom application for the GitHub Actions platform that performs a complex but frequently repeated task. Think of actions as the building blocks of a workflow. If a workflow is a mansion, actions are the components and materials used to build it.

For example, in a workflow, you can have:

An action to change the directory.
An action to check the directory's permissions.
An action to execute the build process.

Jobs

A job is a set of steps in a workflow that are executed on the same runner. Each step is either a shell script or an action to be run.

Difference Between Actions and Jobs:

Actions: The individual building blocks of a workflow.
Jobs: Groups of actions executed on the same runner (server).

With this basic knowledge, you should be ready to dive into GitHub Actions! I hope you find this content useful. Please note that this is just scratching the surface of the iceberg. To dive deeper into GitHub Actions, refer to the official GitHub Actions documentation. The official documentation is always the best place to learn from. 😉

Lessons Learned as a Full-Stack Developer: Building APIs for Easy Front-End Integration

Anadu Godwin — Sun, 12 Jan 2025 12:47:13 +0000

As I’ve journeyed through my career as a full-stack developer, I’ve come to appreciate both the challenges and opportunities in front-end and back-end development. Each side plays a crucial role in shaping the developer experience, and testing both worlds has highlighted the importance of creating seamless interactions between them.

In this post, I’ll share some key lessons I’ve learned about building APIs that simplify front-end integration, along with best practices to avoid common pitfalls.

What is an API?

An Application Programming Interface (API) is a bridge that connects different parts of an application, enabling seamless data exchange. A back-end API, in particular, is built on the server side to power functionality for front-end applications or other services.

Best Practices for Building APIs

1. Maintainability

Design your API so it can be easily modified in the future without introducing major issues. Consistent structure and clear documentation help other developers—and your future self—work more efficiently.

2. Scalability

Your API should handle growth, such as increased user traffic or feature expansion. Efficient database queries and caching mechanisms are critical for scalability.

3. Testability

Always ensure your API is testable. Write automated tests to verify that your API behaves as expected under various conditions.

Handling Query Parameters

Query parameters appear after a question mark (?) in the URL and are commonly used for filtering, sorting, and pagination. For example: https://example.com/products?category=electronics&color=red

Key best practices:

Handle all expected query parameters on the back end. For instance, if your API supports pagination, make sure it processes the page and limit parameters correctly.
Validate and sanitize query parameter values to avoid unexpected issues.

Handling Search Parameters

Search parameters are similar to query parameters but are often embedded in the URL path. For example: https://example.com/search/results?query=laptop

While their purpose overlaps with query parameters, search parameters are more tied to the structure of your application. Ensure they are parsed and processed appropriately to enhance user experience.

Authentication and Authorization

Authentication

This verifies a user's identity to secure your application. Always enforce authentication for endpoints requiring sensitive data access. Reject unauthenticated users before executing business logic.

Authorization

This determines what resources a user can access. For example:

Admin users might have access to all resources.
Regular users might have restricted access.

Best practices: Implement role-based access control (RBAC) to manage permissions effectively.

Clear Error Messages

Helpful error messages make debugging easier for front-end developers. For example:

Bad error message: "Something went wrong."
Good error message: "Sorry, no account found with the provided username."

Use meaningful error codes and messages to improve clarity and usability.

Consistent Data Structure

When returning data to the front end, use a consistent structure. For example: Instead of returning:

{ "products": [...] }

{ "categories": [...] }

Return:

{ "data":[...]}

{ "data": [...] }

This allows front-end developers to write reusable functions, improving code maintainability and scalability.

Conclusion

Building APIs that are easy to integrate and maintain benefits everyone in the development process. By following these best practices, you’ll save yourself and your team countless hours of debugging while improving the overall developer experience.

Remember, the code you write affects your colleagues, so always put yourself in their shoes. I hope you find this post helpful—feel free to share your thoughts or ask questions about API design or anything front-end or back-end related. I’m happy to help!

Learn Docker in Plain English

Anadu Godwin — Wed, 08 Jan 2025 22:09:18 +0000

This post is written to help beginners who are struggling with the overwhelming terminologies used in Docker. If you're just getting started and find Docker concepts confusing, you're in the right place!

If you're reading this, you probably have an interest in understanding Docker. In this post, I’ll explain Docker's basic terms in plain English to make it easier for you to grasp.

What is Docker?

Docker is a tool that helps create and run environments for software. Think of it as a magic box where you can build, share, test, and run applications. It makes working with software faster, easier, and more reliable. And it makes environments easily recreatable.

Key Terms in Docker

Docker Engine
Imagine Docker as a car and Docker Engine as the car's engine. It’s the core technology that powers Docker. It’s open-source and handles everything behind the scenes.

Containers

A container is like a small box that holds everything needed to run an application—code, tools, libraries, and settings. It's lightweight and works the same way across different computers.

Volumes

A volume is a storage space created by Docker where you can save data. It ensures your data isn’t lost when the container is stopped or deleted. Think of it as a shared folder between your application and your computer.

Docker Hub

Docker Hub is like an online app store but for Docker images (pre-configured environments). It allows users to store, share, and download Docker images. Think of it like GitHub or a cloud storage service like Google Drive.

Docker Daemon

The Docker Daemon is like a butler that listens for instructions from the user and carries them out. It manages Docker containers, images, and networks.

Docker Client

The Docker Client is the main way you interact with Docker. It’s usually a command-line tool where you type instructions (commands) to tell Docker what to do.

Docker Desktop

Docker Desktop is the graphical version of Docker. It’s a user-friendly application for those who prefer clicking buttons over typing commands. It simplifies using Docker and makes it more visual.

Summary

Docker might seem overwhelming at first, but with plain English explanations, it becomes much easier to understand. Start with the basics, experiment, and don't be afraid to make mistakes. With time, you'll become comfortable using Docker and see how powerful it is for software development.

Feel free to ask any questions or share your experiences with Docker in the comments!

[Boost]

Anadu Godwin — Sun, 05 Jan 2025 00:04:42 +0000

300+ FREE APIs Every Developer Needs to Know

Hanzla Baig ・ Dec 30 '24

#api #programming #tutorial #opensource

My Journey Deploying an API: From Novice to Docker Enthusiast

Anadu Godwin — Sat, 04 Jan 2025 09:06:03 +0000

Last Month (December 2024), I was tasked to deploy my organization's backend API—a task I had never attempted before. Armed with AWS server credentials and no prior experience, I relied on documentation and online resources to guide me through the setup. Testing the application locally went smoothly, but upon deployment, I hit a major snag: the GraphQL endpoint failed to respond, though the rest of the application was perfectly functional.

When I sought help, a senior engineer simply asked, “Did you deploy it using Docker?” That’s when it hit me: I had missed a critical step. Determined to fix my mistake, I cleaned up the server, removed all dependencies and tools installed initially, and started fresh. This time, I focused on learning Docker.

Initially, I struggled to understand the difference between Dockerfile and Docker Compose and when to use them, but with patience, I began to appreciate Docker’s power and versatility. Once I had the application dockerized and tested locally (breaking my local setup felt safer than risking the server 😅), I redeployed it to the AWS server using a rsync bash script I had written earlier. To my delight, the application ran seamlessly!

To ensure the application stayed running after I exited the server, I used PM2. Combining Docker and PM2 turned out to be a not-great approach, as I later learned. The final task was setting up the domain with Nginx—a challenge I embraced with a sense of nostalgia, having last used Nginx during my ALX-SE training (where we did hard things :)).

The deployment was a success, and my team was impressed. When they asked about my experience with these tools, I had simply said, “I will learn and integrate.” I delivered on that promise within a week. But just as I was celebrating, a new challenge emerged: securing the domain with SSL.

The Final Boss: SSL Configuration

This felt like the ultimate test. I discovered Certbot, an open-source tool for setting up Let's Encrypt certificates, and dived into its documentation. After configuring Certbot, the application crashed entirely. My first thought was to wait 24 hours for the DNS to propagate, but the next day, the domain was still unresponsive.
Debugging this issue without GUI tools was grueling. Docker logs were empty, PM2 refused to start, and error logs offered no clues. After extensive research, I stumbled upon a DigitalOcean guide that mentioned critical firewall commands to execute post-SSL setup:

sudo ufw allow 'Nginx Full'
sudo ufw delete allow 'Nginx HTTP'

These simple commands resolved the issue. It was a hard-fought lesson, but the application was finally live and secured.

Lessons Learned

. Resources Are Limited: At advanced stages of software engineering, you rely more on your brain and experience as there gets to be little or no resources available.
. Tackle Big Challenges: By not shying away from these tasks, I gained valuable skills like Docker, PM2, rsync, debugging, networking, and more.
. Soft Skills Matter: Beyond technical prowess, resilience, problem-solving, and communication play a huge role in your growth.

Final Thoughts

This experience reminded me that “you don’t know how strong you are until being strong is your only choice”. To my fellow juniors: embrace challenges—they are opportunities to grow and surpass your past self.

Why You Should Use ORM Tools in Your Projects in 2025

Anadu Godwin — Sat, 04 Jan 2025 02:28:22 +0000

Introduction

In today’s fast-evolving tech world, developers constantly look for tools that streamline database management and ensure seamless scalability. The Object-Relational Mapper (ORM) is one such tool that makes waves. In this article, I’ll share my experience with Prisma ORM and why adopting ORM tools in your projects can save time, money, and effort—especially as we head into 2025.

Discovering Prisma ORM

My journey with Prisma ORM began during a contribution to the Cal.com repository. The team uses Prisma to handle database queries, and it was immediately clear how powerful and efficient the tool is for managing relational databases. It inspired me to explore Prisma further and eventually integrate it into one of my projects.

The Migration That Made a Difference

Recently, I built a project for a client using Prisma ORM with PostgreSQL as the database. However, as we moved toward deployment, I realized the cost of hosting PostgreSQL was significantly higher than MySQL. Since the client needed a cost-effective solution for maintaining the project after deployment, I migrated the database to MySQL.
Thanks to Prisma, the migration process was seamless. Prisma’s schema management and migration tools handled the complexities behind the scenes, enabling me to focus on ensuring the project met the client’s needs without worrying about database intricacies.

Why Use ORMs in Your Projects?

1. Simplified Database Management
ORMs like Prisma abstract away raw SQL queries, enabling developers to interact with databases using a more intuitive and type-safe API.
Example: With Prisma, you can write queries like:

const user = await prisma.user.findUnique({  
  where: { email: "example@example.com" },  
});

SQL

SELECT *
FROM users
WHERE email = "example@example.com"
LIMIT 1;

2. Cross-Database Compatibility
One standout feature of Prisma is its support for multiple database management systems (DBMS). Whether it’s PostgreSQL, MySQL, SQLite, or even MongoDB, Prisma makes switching between databases straightforward—a benefit I experienced during my migration from PostgreSQL to MySQL.
3. Cost-Effectiveness
As developers, we must consider the long-term costs of hosting and maintaining a database. MySQL proved to be a more affordable option for my client, and Prisma ensured the transition was hassle-free.
4. Future-Proof Your Applications
With 2025 on the horizon, scalability and maintainability are critical for modern applications. ORMs like Prisma provide built-in features like migrations, schema versioning, and type safety, ensuring your app remains adaptable to future changes.

When Should You Consider Using an ORM?

. Projects with complex data models: ORMs simplify the handling of relationships, making it easier to manage entities like users, products, and orders.
. Cross-platform applications: If you’re building apps that may require database changes in the future, ORMs can save hours of manual reconfiguration.
. Budget-conscious projects: As my example shows, ORMs help you navigate cost-effective database choices.

Conclusion

ORM tools like Prisma are invaluable for modern software development. They not only simplify database interactions but also empower developers to create scalable and maintainable solutions. My experience with Prisma, from contributing to Cal.com to migrating a live project database, underscores how transformative these tools can be.

If you’re not using an ORM in your projects yet, 2025 is the perfect time to start. With tools like Prisma, you can focus on building robust applications while leaving the complexities of database management to the ORM.

What’s your take on ORM tools? Have you tried Prisma or any other ORM in your projects? Share your thoughts in the comments or connect with me for more discussions on development tools and practices!

DEV Community: Anadu Godwin

A Beginner's Guide to Docker: Dockerizing Your Application for Easy Deployment

Table of contents:

Introduction

Background/Context

What is a Dockerfile?

Format of a Dockerfile

Understanding the Dockerfile Instructions

Step-by-Step Guide/Tutorial

Setting Up Docker with Docker Desktop

Docker Init Command

Benefits/Advantages of Docker

Challenges/Considerations

Conclusion

Glossary

The Power of GraphQL: A Beginner’s Guide to Modern Web Development

The History of GraphQL: How and Why It Was Invented

GraphQL Architectures: How It Works

Great Products Built Using GraphQL

Conclusion

Glossary

GitHub Actions Made Simple: A Beginner’s Guide to CI/CD Automation

What is GitHub Actions?

Knowledge Required to Get Started with GitHub Actions

Must-Have:

Optional Skills:

Table of Contents

Workflow

Naming Conventions:

When You May Need a Workflow:

Event

Runners

Actions

Jobs

Difference Between Actions and Jobs:

Lessons Learned as a Full-Stack Developer: Building APIs for Easy Front-End Integration

What is an API?

Best Practices for Building APIs

1. Maintainability

2. Scalability

3. Testability

Handling Query Parameters

Handling Search Parameters

Authentication and Authorization

Authentication

Authorization

Clear Error Messages

Consistent Data Structure

Conclusion

Learn Docker in Plain English

What is Docker?

Key Terms in Docker

Containers

Volumes

Docker Hub

Docker Daemon

Docker Client

Docker Desktop

Summary

[Boost]

300+ FREE APIs Every Developer Needs to Know

Hanzla Baig ・ Dec 30 '24

My Journey Deploying an API: From Novice to Docker Enthusiast

The Final Boss: SSL Configuration

Lessons Learned

Final Thoughts

Why You Should Use ORM Tools in Your Projects in 2025

Introduction

Discovering Prisma ORM

The Migration That Made a Difference

Why Use ORMs in Your Projects?

When Should You Consider Using an ORM?

Conclusion