How to Install Odoo 18 With PostgreSQL 17 and Create a Custom “Hello World” Module
Let's linked LinkedIn

Imagine this: you’re setting up your development environment, your coffee’s still warm, and you’ve just finished a recent tweak to your code. Now you’re ready to see your very own custom module light up the Odoo interface with a simple “Hello World!” message—all powered by Odoo 18 and PostgreSQL 17 running in Docker. Today, I’m going to walk you through every step of this process. Whether you’re an experienced developer or just dipping your toes into the world of Odoo, this guide is designed to be approachable, detailed, and, above all, human.

Introduction: The Joy of Building Something Custom

Every developer knows that there’s a unique thrill in creating something from scratch—a project that’s entirely your own. There’s a sense of pride when your custom code transforms into an interactive, functioning module within a larger system. In this tutorial, we’ll not only set up Odoo 18 to run alongside PostgreSQL 17 but also craft a custom module named custom_hello. This module will display a “Hello World!” message when you navigate to a specific URL. It may sound basic, but the process unveils the magic behind Odoo’s modular architecture. More importantly, it lays the foundation for the next big idea you might have brewing.

We’ll break everything down into manageable steps: setting up your development environment with Docker Compose, creating the custom module, integrating it with Odoo, and testing it—all while making sure your setup is modern, efficient, and robust.

1. Setting Up Your Environment

Before we dive into the code, let’s take a moment to outline our workspace. Imagine your project directory organized like this:

/home/yourname/odoo18/
├── addons
│   └── custom_hello
│       ├── __init__.py
│       ├── __manifest__.py
│       └── controllers
│           ├── __init__.py
│           └── main.py
├── config
├── docker-compose.yml
└── ...

This structure is simple yet powerful. The addons directory contains our custom modules, and the config directory holds configurations such as the Odoo configuration file (which we’ll set up shortly). The heart of our environment is our docker-compose.yml file—a configuration that seamlessly brings together our Odoo and PostgreSQL containers.

Docker Compose: The Backbone of Our Setup

Our Docker Compose file is what ties everything together. It defines the services that power our environment, mapping our host directories into the running containers so that changes you make on your host are visible immediately in your Odoo instance.

Here’s an example configuration:

version: '3.8'

services:
  web:
    image: odoo:18.0
    depends_on:
      db:
        condition: service_healthy
    ports:
      - "8069:8069"
    volumes:
      - odoo-web-data:/var/lib/odoo
      - ./config:/etc/odoo:ro   # Mount configuration as read-only
      - ./addons:/mnt/extra-addons:ro   # Mount custom addons as read-only
    environment:
      DB_HOST: db
      DB_USER: odoo
      DB_PASSWORD: odoo
    restart: always
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8069"]
      interval: 30s
      timeout: 10s
      retries: 5

  db:
    image: postgres:17
    environment:
      POSTGRES_DB: postgres
      POSTGRES_USER: odoo
      POSTGRES_PASSWORD: odoo
    volumes:
      - odoo-db-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U odoo"]
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  odoo-web-data:
  odoo-db-data:

What’s Happening in This File?

  • Version 3.8:
    Upgrading to this version unlocks new Docker Compose features like enhanced healthcheck syntax and extended service definitions. It’s a modern approach that keeps your deployment future-proof.

  • Services:
    We define two key services:

    • web: This is our Odoo container. Notice how it depends on the db service, and thanks to the condition: service_healthy setting, it waits until PostgreSQL is up and ready before starting.
    • db: Running PostgreSQL 17, this service handles our persistent storage. Its environment variables ensure the correct database, user, and password configuration.

  • Volumes and Mounts:
    The Compose file mounts your host’s ./config and ./addons directories into the container. This means that any changes you make to custom modules or configurations are automatically reflected inside the running container. The :ro (read-only) option is used for security, ensuring that sensitive configuration files and custom addons aren’t inadvertently modified by the container process.

  • Environment Variables and Healthchecks:
    Clear, explicit naming of environment variables (like DB_HOST) improves readability and simplifies debugging. Healthchecks ensure that each service is truly ready before dependencies start interacting, which is invaluable in complex setups.

To bring your environment up and running, navigate to your project directory and execute:

docker-compose up -d

This command starts your services in detached mode, allowing you to work while the containers run in the background.

2. Building the Custom Module: “Hello World!”

Now that your environment is set up, it’s time to get your hands dirty with some code. In this section, we’ll create a simple custom module that greets users with a “Hello World!” message when they visit a specific URL.

a. Module Structure

First, create a folder named custom_hello inside your addons directory. The directory structure should look like this:

custom_hello/
├── __init__.py
├── __manifest__.py
└── controllers/
    ├── __init__.py
    └── main.py

  • __init__.py (module root):
    This file can be empty or used to import additional submodules if your module expands in the future.

  • __manifest__.py:
    This file contains metadata about your module. Think of it as the module’s business card—it tells Odoo what your module is, who wrote it, and what dependencies it requires.

b. Writing the Manifest

In the file custom_hello/__manifest__.py, add the following content:

{
    'name': 'Custom Hello Module',
    'version': '1.0',
    'summary': 'A simple module to display Hello world!',
    'description': """
        This module displays a simple 'Hello world!' message.
    """,
    'author': 'Your Name',
    'category': 'Tools',
    'depends': ['base'],  # Add other dependencies as needed.
    'data': [],
    'installable': True,
    'application': True,
}

This configuration tells Odoo all about your custom module. It declares that your module depends on the base Odoo system, provides a short description, and marks the module as installable.

c. Creating the Controller

Next, let’s create the controller that handles the request. In custom_hello/controllers/main.py, insert the following code:

from odoo import http

class HelloWorld(http.Controller):
    @http.route('/hello', auth='public')
    def hello(self, **kw):
        return "Hello world!"

Here’s how it works:

  • The controller defines a single route, /hello, which can be accessed by anyone (as indicated by auth='public').
  • When you navigate to http://localhost:8069/hello, this controller returns a plain-text response—“Hello world!”.

It’s a minimal example, but it forms the foundation for more complex functionality later on.

3. Integrating and Testing with Docker

With your module created, it’s time to integrate it into your Odoo environment and see it in action.

a. Place the Module in the Addons Path

Make sure your custom module is located in the correct directory that your Docker container is mounting. For instance:

/home/yourname/odoo18/addons/custom_hello/

Because our Docker Compose file mounts the entire addons directory into /mnt/extra-addons (as read-only), Odoo will automatically pick up any module you add there.

b. Running the Docker Containers

If you haven’t already started your containers, you can bring them up with:

docker-compose up -d

If the containers are already running, any changes to your module files on your host system will be reflected immediately in the running instance—thanks to the volume mounts.

c. Updating the Module in Odoo

Once your containers are running, open your browser and navigate to http://localhost:8069. Log in to your Odoo instance, and if you’re in Developer Mode, update the Apps List via the Apps menu. Your custom module, “Custom Hello Module”, should now appear. Simply click it to install.

After installation, navigate to http://localhost:8069/hello. If everything is set up correctly, you’ll see the “Hello world!” message displayed.

4. Reflecting on the Journey and Next Steps

There’s something truly satisfying about seeing that “Hello world!” message—it’s more than just text on a screen. It represents the successful integration of multiple technologies working in harmony:

  • Odoo 18, a powerful business management platform.
  • PostgreSQL 17, a modern and reliable database backend.
  • Docker Compose, which acts as the glue holding everything together.

Each step in this process—from configuring Docker to writing a simple module—builds your expertise and paves the way for more advanced customizations. Today’s exercise might be as simple as a greeting, but it’s a launchpad. Imagine expanding the custom_hello module to introduce dynamic data, interactive dashboards, or even integrating with external APIs. The possibilities are endless.

A Few Thoughts on Your Odoo Development Journey

  • Continuous Improvement:
    As you develop more modules, keep refining your environment. Docker’s volume mounts allow you to develop on your host machine with your favorite editor, while Docker ensures consistency in production.

  • Testing and Debugging:
    Consider setting up unit tests using frameworks like pytest and running integration tests to ensure that your changes don’t break existing functionality. Tools like docker-compose logs -f web can be lifesavers when troubleshooting issues in a containerized environment.

  • Security and Best Practices:
    As your modules become more advanced, you might eventually need to restrict access to certain routes. Changing the authentication parameter from auth='public' to auth='user' in your controllers can enforce login requirements. For instance:

    @http.route('/hello', auth='user', website=True)
def hello(self, **kw):
    return http.request.render("custom_hello.hello_page_template", {})

    This ensures that only authenticated users can access sensitive parts of your application.

  • Documentation and Community:
    Keep a log or blog of your progress. Documenting your journey not only helps you remember what you’ve learned, but it also helps other developers who might face similar challenges. The Odoo community is rich with knowledge and resources—don’t hesitate to share your experiences and ask questions.

Conclusion: Your Next Chapter in Odoo Development

What will you build next? With Odoo 18 running alongside PostgreSQL 17 in a robust Docker environment, and with your custom “Hello World!” module as your starting point, the sky’s the limit. Embrace the challenge, experiment with new features, and let your creativity drive your next project.

Every line of code you write, every container you launch, and every module you develop is a step forward in your growth as a developer. As you continue to explore and build, remember that the journey is just as important as the destination. So take a moment to savor that “Hello world!”—it’s the first word in a story only you can write.

If you have questions, comments, or just want to share what you’ve built, drop a comment below or connect on social media. Happy coding, and here’s to building something truly remarkable with Odoo 18!

Keywords: Odoo 18, PostgreSQL 17, Docker, custom module, Hello world, Odoo development, Odoo tutorial

Tags: Odoo 18  PostgreSQL 17  Docker  Custom Module  Hello World  Odoo Tutorial