Spring Boot & MySQL Docker Trouble On Hostinger VPS

Nov 1, 2025 by Andrew McMorgan 52 views

Hey Plastik Magazine readers, ever wrestled with Docker, Spring Boot, and MySQL all at once? If you're nodding, then you're in the right place! Today, we're diving deep into a common head-scratcher: getting your Spring Boot app to play nice with a MySQL database when they're both chilling in Docker containers, especially when you're hosting on a Hostinger VPS. I've been there, staring at those connection refused errors, and I'm here to walk you through it. We'll break down the usual suspects, debug some common issues, and get your setup running smoothly. Let's get started, shall we?

The Docker Compose Setup: A Quick Overview

First off, let's take a quick peek at the docker-compose.yml file that's likely causing the headache. This file is the blueprint for how your containers are born and interact. It's the heart of your Dockerized application, specifying the services, their images, ports, and network configurations. Understanding this file is key to troubleshooting any connection issues. Here's a typical example, but remember, the specifics might vary based on your project. The critical elements are the service definitions for both your Spring Boot application and your MySQL database. Pay close attention to the image used, the ports exposed, and how the containers are networked. This file is your first line of defense in diagnosing and fixing connection issues.

Let's assume, for example, that your docker-compose.yml looks something like this:

version: '3.8'
services:
  mysql:
    image: mysql:8
    container_name: mysql-db
    restart: always
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: "your_root_password"
      MYSQL_DATABASE: "your_database_name"
      MYSQL_USER: "your_user"
      MYSQL_PASSWORD: "your_password"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - app-network

  spring-boot-app:
    image: your-spring-boot-app:latest
    container_name: spring-boot-app-container
    depends_on:
      - mysql
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: "jdbc:mysql://mysql:3306/your_database_name?useSSL=false"
      SPRING_DATASOURCE_USERNAME: "your_user"
      SPRING_DATASOURCE_PASSWORD: "your_password"
    networks:
      - app-network

volumes:
  mysql_data:

networks:
  app-network:
    driver: bridge

In this example, the mysql service uses the official MySQL 8 image. It exposes port 3306 and sets environment variables for the database credentials. The spring-boot-app service uses a custom image for your Spring Boot application. It depends on the mysql service, meaning it will start after MySQL is up and running. The environment variables in spring-boot-app configure the connection to the MySQL database. Critically, both services are connected to the app-network. This network is what allows the containers to communicate with each other using the service names as hostnames. The depends_on ensures that MySQL is ready before Spring Boot tries to connect. Make sure your environment variables in the Spring Boot application match the ones set up in the MySQL service for smooth communication. This initial setup is the foundation; understanding it makes debugging much easier.

Common Connection Issues and How to Squash Them

Alright, let's talk about the usual culprits when your Spring Boot app and MySQL container refuse to shake hands. Network configuration is often the root of the problem. Inside a Docker Compose network, containers can talk to each other using their service names as hostnames. So, in the example above, your Spring Boot app should be able to connect to MySQL using mysql as the hostname and port 3306. Double-check your SPRING_DATASOURCE_URL to ensure it's pointing to the correct hostname and port. Another common issue is firewall settings. Hostinger VPS instances often have firewalls that might block incoming connections. Make sure that port 3306 is open in your VPS's firewall settings. You might need to add a rule to allow traffic on that port. Examine your firewall rules, and configure them to allow traffic to the necessary ports, such as port 3306 for MySQL. Check the Hostinger control panel or use tools like ufw or iptables to manage your firewall. Verify that the MySQL container is listening on the correct port and that the Spring Boot application is configured to connect to that port.

Environment variables are another area to thoroughly inspect. Incorrectly configured environment variables can cause havoc. The SPRING_DATASOURCE_URL, SPRING_DATASOURCE_USERNAME, and SPRING_DATASOURCE_PASSWORD variables in your Spring Boot application must match the database credentials set in your docker-compose.yml file. Misconfigured credentials here are a frequent cause of connection failures. Double-check that these variables align perfectly with your MySQL setup. Also, ensure you haven't misspelled any of the environment variable names. A tiny typo can break the entire connection. Volumes also play a crucial role, especially with database persistence. If you are using volumes to persist your database data, confirm that the volume paths are correctly configured and that the MySQL container has the appropriate permissions to access them. Incorrect volume settings can lead to data loss or database startup issues. When running docker-compose up, watch the logs from both the MySQL and Spring Boot containers for any error messages. These logs are treasure troves of information. Spring Boot will typically display database connection errors, and MySQL might indicate permission or configuration problems. Scrutinize these logs carefully to get a clearer picture of what's going wrong. Start with the basics: are the containers running? Are they on the same network? Is the database accessible? Only by addressing these core questions can you move on to more advanced troubleshooting.

Troubleshooting Steps: Get Your Hands Dirty

So, your Spring Boot app still can't connect? Don't panic, guys; let's get into some practical troubleshooting steps. First, let's verify network connectivity. Inside your Spring Boot container, try pinging the MySQL service. You can use the docker exec command to open a shell inside the container:

docker exec -it spring-boot-app-container bash
ping mysql

If you can't ping mysql, there's a network issue. Check your docker-compose.yml to ensure both services are on the same network. If you can ping, then the network is working. Next, verify the MySQL container's status. Use docker ps to see if the MySQL container is running. If it's not, check the logs with docker logs mysql-db to find out why. Look for any startup errors or permission issues. Make sure the MySQL container is up and running without errors. If the MySQL container is running, use docker exec to connect to it and check its status. Another helpful tip is to try connecting to the database manually from within the Spring Boot container. You can use the mysql command-line client to test the connection. First, install the MySQL client inside the container, if it's not already there. Then, use the credentials from your docker-compose.yml to connect to the database. For example:

docker exec -it spring-boot-app-container bash
mysql -h mysql -u your_user -p

Enter your password when prompted. If this connection fails, there's likely an issue with your credentials or the MySQL server itself. Finally, check your Spring Boot application's configuration. Ensure that your application.properties or application.yml file has the correct database connection details. These settings override the environment variables set in docker-compose.yml, so make sure they match. Review your application logs for detailed connection errors and stack traces. These logs often provide valuable clues about the root cause of the problem. Don't underestimate the power of these steps; they will help you pinpoint the issue and take the correct course of action. If you've tried these steps and still can't connect, you might want to consider specific Hostinger VPS configurations.

Hostinger-Specific Considerations

If you're hosting on Hostinger, there might be some Hostinger-specific settings that could be tripping you up. Firewall settings are a prime example. Hostinger VPS instances often come with a firewall pre-configured. You'll need to make sure that the necessary ports (like 3306) are open in your VPS's firewall settings to allow traffic to your MySQL container. Check your Hostinger control panel or use tools like ufw or iptables to manage your firewall. Make sure the firewall isn't blocking the connection. Network configurations on your Hostinger VPS might also influence how Docker containers communicate. Ensure that Docker's network settings are correctly configured and that your containers can communicate with each other. Sometimes, the default network settings might not be optimal, and you might need to adjust them. Resource limitations on your VPS could be another factor. A resource-constrained VPS might not be able to handle the load of both Spring Boot and MySQL containers, especially during startup. Monitor your VPS's CPU, memory, and disk usage to identify any resource bottlenecks. If you're hitting resource limits, consider upgrading your VPS plan or optimizing your application. Hostinger's support documentation is also a good resource. Consult their documentation for any specific configurations or requirements related to Docker and MySQL on their VPS. Hostinger's support team can also provide assistance. Don't hesitate to reach out to their support if you're stuck, as they can offer valuable insights specific to their platform. By paying close attention to these Hostinger-specific factors, you can effectively troubleshoot and resolve connection problems.

Advanced Tips and Tricks

Once you've got the basics covered, here are some advanced tips to elevate your debugging game. Use a database management tool: Install a database management tool, like DBeaver or MySQL Workbench, on your local machine and connect to your MySQL container. This allows you to inspect the database, check tables, and verify data, helping you to identify issues that may not be apparent in the logs. Enable detailed logging: Enhance your logging configuration in both your Spring Boot application and MySQL container to get more granular information. For Spring Boot, adjust your application.properties or application.yml to set the log level to DEBUG or TRACE for database-related components. For MySQL, configure the log settings in your my.cnf file or through environment variables. This can provide valuable insights into what's happening during the connection process.

Inspect the Docker network: Use Docker commands to inspect the network your containers are on. This can give you a better understanding of the network configuration and identify potential issues. For instance, use docker network inspect app-network to see details about the network, including the IP addresses of the containers and any connected subnets. Test with a simple connection: Create a simple Java program that attempts to connect to your MySQL database to isolate the issue. This allows you to eliminate potential problems with Spring Boot and focus on the database connection itself. If the simple program fails, the problem lies with the database connection, rather than Spring Boot. Consider using Docker Compose's health checks: Implement health checks in your docker-compose.yml file to ensure that your containers are running correctly. Health checks can automatically restart containers if they become unhealthy, improving the overall reliability of your setup. Implementing health checks can prevent many unexpected issues. Consider these advanced techniques once you have addressed the core issues.

Conclusion: You Got This!

Alright, guys, you've got the tools and the knowledge to conquer those Spring Boot and MySQL connection issues in Docker on your Hostinger VPS. Remember to carefully examine your docker-compose.yml file, double-check your environment variables, and verify your network and firewall settings. Scrutinize those logs, ping those containers, and don't be afraid to get your hands dirty with some command-line troubleshooting. The journey can be challenging, but with persistence, you'll get everything working smoothly. If you've tried everything and still can't connect, revisit the fundamentals. Keep learning, keep experimenting, and don't hesitate to ask for help from the community. Docker can be challenging, but it offers immense power and flexibility once you've mastered the basics. Best of luck, and happy coding!