depends_on is deprecated in docker-compose v3

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:

#!/bin/bash

# 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
max_attempts=10
attempt=1

# 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))
done

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

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.

# config.py

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

# main.py

from fastapi import FastAPI
from app.api import users

app = FastAPI()

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

# .env

POSTGRES_USER=username
POSTGRES_PASSWORD=password
POSTGRES_DB=database_name

from fastapi import FastAPI

app = FastAPI()

@app.get("/users/{user_id}")
def get_user(user_id: int):
    # Retrieve user information from the database
    user = get_user_from_database(user_id)
    return user

from fastapi import FastAPI, Depends
from fastapi.security import OAuth2PasswordBearer

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

@app.get("/users/me")
def get_current_user(token: str = Depends(oauth2_scheme)):
    # Verify and decode the JWT token
    user = verify_and_decode_token(token)
    return user

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

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