depends_on is deprecated in docker-compose v3
  • 17-May-2023
Lightrun Team
Author Lightrun Team
depends_on is deprecated in docker-compose v3

depends_on is deprecated in docker-compose v3

Lightrun Team
Lightrun Team

Explanation of the problem


The issue at hand pertains to the behavior of the depends_on directive in Docker Compose. Previously, the depends_on directive would wait for a container to be “ready” before initiating the startup of another container that depends on it. However, there has been a change in the behavior where depends_on now only waits for the container to be started, without considering its readiness. Consequently, to ensure that a dependent container is truly ready, it is necessary to implement a retry loop mechanism.

The problem arises during the deployment process when encountering an error related to the deploy script and the depends_on configuration for the services.pgadmin container. Specifically, the error message indicates that depends_on should be specified as a list. In order to address this issue, the depends_on lines are removed from the configuration, which resolves the error. This aligns with the documented behavior where depends_on no longer waits for services to be “ready,” but only until they have been started.

It is worth considering that other users might have encountered a similar problem, although the absence of widespread reports suggests it may not be a prevalent issue. Removing the depends_on lines resolved the error in this particular case. However, it is essential to carefully evaluate the specific requirements of your project and assess the impact of removing depends_on on the overall functionality and readiness of the services. It is advisable to consult the documentation and thoroughly understand the implications before making any modifications to the depends_on configuration.


Troubleshooting with the Lightrun Developer Observability Platform


Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for: depends_on is deprecated in docker-compose v3


To address the problem of the depends_on directive not waiting for a container to be “ready,” you can implement a retry mechanism in your deployment script. This approach ensures that the dependent container is fully operational before proceeding with the startup of other containers.

Here’s an example of how you can implement a simple retry loop in your deployment script using a shell script:



# Function to check if the container is ready
is_container_ready() {
  # Replace <container-name> with the actual name of your container
  docker inspect --format='{{.State.Status}}' <container-name> | grep -q "running"

# Retry loop with a maximum number of attempts

# Wait for the container to be ready or reach the maximum number of attempts
while ! is_container_ready && [ $attempt -le $max_attempts ]; do
  sleep 5  # Adjust the sleep duration as needed
  attempt=$((attempt + 1))

# Check if the container is ready
if is_container_ready; then
  echo "Container is ready. Proceed with startup."
  # Add your startup commands here
  echo "Container is not ready after $max_attempts attempts. Deployment failed."


By using this retry loop, the script will wait for the container to be fully started before continuing with the startup process. Adjust the sleep duration and the maximum number of attempts according to your specific requirements.

It’s important to note that this approach assumes that the container being checked has appropriate health checks or indicators of readiness. Adjust the is_container_ready function accordingly to match your specific case. Additionally, consider integrating this retry mechanism into your deployment workflow or infrastructure automation tools to ensure consistent behavior across environments.


Problems with full-stack-fastapi-postgresql


  1. Database Connection Issues: Problem: One common issue is establishing a connection to the PostgreSQL database. This can result in errors and prevent the application from accessing or updating data.

Solution: Verify the database connection configuration and ensure that the required dependencies are properly installed. Check the database URL, credentials, and network settings. Here’s an example of the configuration file ( that specifies the database connection details:



DATABASE_URL = "postgresql://username:password@localhost:5432/database_name"


Ensure that the PostgreSQL server is running, and the provided credentials match those of the PostgreSQL user. Additionally, make sure the required PostgreSQL Python package is installed (psycopg2 or asyncpg) to establish the database connection.

  1. API Endpoint Errors: Problem: When developing an API using full-stack-fastapi-postgresql, errors can occur when defining or implementing the API endpoints. This can result in incorrect or inconsistent data retrieval or storage.

Solution: Review and debug the API endpoint code to identify any syntax errors or logic issues. Pay attention to the route definitions, request methods (GET, POST, etc.), and corresponding function implementations. Ensure that the appropriate models and database queries are used to perform the desired operations. Here’s an example of defining an API endpoint that retrieves a user’s data:



from fastapi import FastAPI
from app.api import users

app = FastAPI()

app.include_router(users.router, prefix="/users", tags=["users"])


Review the implementation of the users API router to handle the specific endpoints related to user data, such as creating, updating, or retrieving user information.

  1. Deployment and Environment Setup: Problem: Deploying a full-stack-fastapi-postgresql application and configuring the environment settings can be challenging. Issues may arise when deploying the application to different platforms or when managing environment-specific configurations.

Solution: Follow the deployment and environment setup instructions provided in the project documentation. Pay attention to the specific deployment platform requirements, such as Docker, Heroku, or AWS. Ensure that all necessary environment variables are set correctly, including the database connection details, secret keys, and other application-specific configurations. For example, when using Docker, create a .env file with the required environment variables:


# .env



Refer to the project’s documentation or deployment guides for detailed instructions on configuring the environment and deploying the application.

By addressing these common problems, developers can overcome hurdles when working with the full-stack-fastapi-postgresql stack and ensure a smooth development and deployment experience.


A brief introduction to full-stack-fastapi-postgresql


The full-stack-fastapi-postgresql stack is a powerful combination of technologies that enables developers to build full-stack web applications with ease. It leverages FastAPI, PostgreSQL, and additional tools to provide a robust and efficient development environment.

FastAPI is a modern, high-performance web framework for building APIs with Python. It offers an intuitive and easy-to-use interface, along with automatic request validation and documentation generation. FastAPI utilizes asynchronous capabilities to handle a large number of concurrent requests efficiently, making it an ideal choice for building scalable web applications.

PostgreSQL, a popular open-source relational database management system, is the database component of the full-stack-fastapi-postgresql stack. It provides reliability, ACID compliance, and advanced features for data management and storage. With its support for complex queries, indexes, and transactions, PostgreSQL offers a solid foundation for storing and retrieving data in a structured manner.

By combining FastAPI’s robustness and performance with PostgreSQL’s data management capabilities, the full-stack-fastapi-postgresql stack enables developers to create feature-rich web applications that handle data effectively. Whether it’s building RESTful APIs, implementing authentication and authorization mechanisms, or handling complex database operations, this stack provides the necessary tools and components to streamline the development process and deliver high-quality applications.


Most popular use cases for full-stack-fastapi-postgresql


  1. Building RESTful APIs: With the full-stack-fastapi-postgresql stack, developers can create powerful and scalable RESTful APIs. FastAPI’s intuitive syntax and automatic documentation generation make it easy to define API endpoints and handle various HTTP methods. Here’s an example of defining an API endpoint for retrieving a user’s information:


from fastapi import FastAPI

app = FastAPI()

def get_user(user_id: int):
    # Retrieve user information from the database
    user = get_user_from_database(user_id)
    return user


  1. Implementing Authentication and Authorization: Security is a crucial aspect of web applications, and the full-stack-fastapi-postgresql stack provides tools to handle authentication and authorization. Developers can integrate authentication mechanisms like JWT (JSON Web Tokens) for user authentication and authorization. Here’s an example of protecting an API endpoint with authentication:


from fastapi import FastAPI, Depends
from import OAuth2PasswordBearer

app = FastAPI()
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")

def get_current_user(token: str = Depends(oauth2_scheme)):
    # Verify and decode the JWT token
    user = verify_and_decode_token(token)
    return user


  1. Handling Complex Database Operations: PostgreSQL, as the database component of the stack, enables developers to handle complex database operations efficiently. It supports advanced SQL features, indexes, and transactions, allowing for robust data management. Developers can perform operations like querying data, inserting records, updating data, and executing custom SQL statements. Here’s an example of inserting a new user record into the database:


from sqlalchemy import insert
from app.models import User
from app.database import database

async def create_user(user: User):
    query = insert(User).values(,
    last_record_id = await database.execute(query)
    return last_record_id


With these capabilities, the full-stack-fastapi-postgresql stack empowers developers to build feature-rich web applications with a focus on performance, scalability, security, and efficient data management.


It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications.

Try Lightrun’s Playground

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.