MongoError: getaddrinfo ENOTFOUND mongo mongo:27017
  • 05-Jun-2023
Lightrun Team
Author Lightrun Team
MongoError: getaddrinfo ENOTFOUND mongo mongo:27017

MongoError: getaddrinfo ENOTFOUND mongo mongo:27017

Lightrun Team
Lightrun Team

Explanation of the problem

When attempting to run the project following the instructions provided in the README, the following error is encountered:


> jincor-backend-ico-dashboard@0.0.1 start /usr/src/app
> nodemon -w ./src -e ts ./src/bin/www --exec ts-node

[nodemon] 1.12.1
[nodemon] to restart at any time, enter `rs`
[nodemon] watching: /usr/src/app/src/**/*
[nodemon] starting `ts-node ./src/bin/www`
TypeORM connection error:  { MongoError: failed to connect to server [mongo:27017] on first connect [MongoError: getaddrinfo ENOTFOUND mongo mongo:27017]
    at Pool.<anonymous> (/usr/src/app/node_modules/mongodb-core/lib/topologies/server.js:336:35)
    at emitOne (events.js:116:13)
    at Pool.emit (events.js:211:7)
    at Connection.<anonymous> (/usr/src/app/node_modules/mongodb-core/lib/connection/pool.js:280:12)
    at Object.onceWrapper (events.js:317:30)
    at emitTwo (events.js:126:13)
    at Connection.emit (events.js:214:7)
    at Socket.<anonymous> (/usr/src/app/node_modules/mongodb-core/lib/connection/connection.js:187:49)
    at Object.onceWrapper (events.js:315:30)
    at emitOne (events.js:116:13)
    at Socket.emit (events.js:211:7)
    at emitErrorNT (internal/streams/destroy.js:64:8)
    at _combinedTickCallback (internal/process/next_tick.js:138:11)
    at process._tickDomainCallback (internal/process/next_tick.js:218:9)
  name: 'MongoError',
  message: 'failed to connect to server [mongo:27017] on first connect [MongoError: getaddrinfo ENOTFOUND mongo mongo:27017]' }


The error message suggests a connection problem with TypeORM to the MongoDB server. The connection attempt fails with the following details: failed to connect to server [mongo:27017] on first connect [MongoError: getaddrinfo ENOTFOUND mongo mongo:27017].


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: MongoError: getaddrinfo ENOTFOUND mongo mongo:27017

To resolve this issue, it is necessary to ensure that the MongoDB server is running and accessible at the specified address and port (mongo:27017). Additionally, make sure that the MongoDB configuration in the project is correctly set up to connect to the MongoDB instance. Verify the hostname, port, authentication credentials, and any other necessary parameters.

Here’s an example of the MongoDB connection configuration that needs to be checked and adjusted if necessary:


import { createConnection } from 'typeorm';

  type: 'mongodb',
  host: 'mongo',
  port: 27017,
  username: 'your_username',
  password: 'your_password',
  database: 'your_database',
  // additional configuration options...
  .then(() => {
    console.log('Successfully connected to MongoDB.');
    // Continue with other initialization steps or start the server.
  .catch((error) => {
    console.error('MongoDB connection error:', error);
    // Handle the connection error appropriately.


Ensure that the MongoDB server is running, the necessary dependencies are installed, and the connection configuration is correctly set up.


Other popular problems with backend-ico-dashboard


Problem 1: Authentication Failure

One common issue with the backend-ico-dashboard is authentication failure. When attempting to authenticate with the application, users may encounter an error indicating that the authentication process has failed. The error message might look like the following:


Authentication failed: Invalid credentials.


This problem typically occurs when the provided credentials, such as username or password, are incorrect or do not match the expected format. To resolve this issue, users should double-check their credentials and ensure they are entered correctly. Here’s an example of how the authentication process can be implemented in a Node.js application using a library like Passport.js:


const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const User = require('./models/User');

// Configure passport to use local strategy for authentication
  new LocalStrategy((username, password, done) => {
    User.findOne({ username: username }, (err, user) => {
      if (err) return done(err);
      if (!user) return done(null, false);
      if (!user.verifyPassword(password)) return done(null, false);
      return done(null, user);

// Implement authentication route'/login', passport.authenticate('local'), (req, res) => {
  // Authentication successful, perform further actions
  res.json({ message: 'Authentication successful' });


Ensure that the provided credentials match the expected format and that the authentication process is correctly implemented. Additionally, make sure the user data is properly stored and retrieved from the database, and the password verification logic is working correctly.

Problem 2: Database Connection Issue

Another common problem with the backend-ico-dashboard is a database connection issue. This problem occurs when the application fails to establish a connection with the database server. Users might encounter an error message similar to the following:


Failed to connect to the database: Connection refused.


This issue typically arises due to misconfiguration of the database connection settings or the database server being unavailable. To address this problem, users should verify the correctness of the database connection settings, such as the host, port, username, password, and database name. Here’s an example of how the database connection can be established using the Mongoose library in a Node.js application:


const mongoose = require('mongoose');

// Connect to the MongoDB database
  .connect('mongodb://localhost:27017/mydatabase', {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  .then(() => {
    console.log('Successfully connected to the database.');
    // Continue with other application initialization steps
  .catch((error) => {
    console.error('Failed to connect to the database:', error);
    // Handle the database connection error appropriately


Ensure that the database server is running and accessible, and the connection settings in the application code are accurate. Additionally, check for any firewall or network-related issues that may be blocking the database connection.

Problem 3: Authorization Error

The backend-ico-dashboard may encounter authorization errors when users attempt to access certain resources or perform restricted actions. An authorization error message might look like the following:


Authorization failed: You are not authorized to perform this action.


This problem occurs when a user lacks the necessary permissions or roles to access or perform the requested operation. To resolve this issue, users should ensure that they have the appropriate credentials or roles assigned to their account. Here’s an example of how authorization can be implemented using a role-based access control (RBAC) approach:


// Middleware to check if the user has the required role
function requireRole(role) {
  return (req, res, next) => {
    if (req.user && req.user.role === role) {
      next(); // User has the required role, proceed
    } else {
      res.status(403).json({ message: 'You are not authorized to perform this action.' });

// Protected route that requires admin role
app.get('/admin', requireRole('admin'), (req, res) => {
  // Handle the request for admin-only functionality
  res.json({ message: 'Admin-only functionality' });


Ensure that the user roles are correctly assigned and stored in the user model or database. Implement appropriate authorization checks for different routes or actions based on the user’s role. Additionally, make sure to handle authorization errors gracefully and provide meaningful error messages to the user.


A brief introduction to backend-ico-dashboard

The backend-ico-dashboard is a web application built to provide administrative functionality and support for an initial coin offering (ICO) project. It serves as the backend component of the ICO dashboard system, enabling users to manage various aspects of the ICO project, including user authentication, database management, and authorization controls. The application is typically developed using frameworks and technologies such as Node.js, Express.js, and MongoDB, which provide a robust and scalable foundation for building web applications.

At its core, the backend-ico-dashboard focuses on providing secure and reliable APIs for user authentication and authorization. It incorporates features like token-based authentication using technologies such as JSON Web Tokens (JWT), ensuring that only authenticated users can access protected resources. Additionally, the application employs role-based access control (RBAC) mechanisms to enforce fine-grained authorization, allowing administrators to define specific roles and permissions for different user types. By implementing these security measures, the backend-ico-dashboard ensures that only authorized users can perform privileged actions and access sensitive information.

The backend-ico-dashboard also leverages a database management system, typically MongoDB, to store and retrieve data related to the ICO project. It facilitates seamless integration with the database, enabling the application to manage user accounts, store ICO-related data, and perform various CRUD (Create, Read, Update, Delete) operations efficiently. With proper data modeling and schema design, the backend-ico-dashboard ensures data consistency and provides robust data manipulation capabilities. This allows users to retrieve and manipulate ICO-related information, generate reports, and perform analytics to support decision-making processes throughout the ICO project lifecycle.


Most popular use cases for backend-ico-dashboard


  1. User Authentication and Authorization: The backend-ico-dashboard provides a comprehensive solution for user authentication and authorization. It allows developers to implement secure user registration, login, and password management functionalities. By utilizing JSON Web Tokens (JWT), developers can generate and verify tokens to authenticate users and authorize access to protected resources. Here’s an example code snippet demonstrating token generation and verification using the jsonwebtoken library in Node.js:


const jwt = require('jsonwebtoken');

// Generate JWT token
const token = jwt.sign({ userId: }, secretKey, { expiresIn: '1h' });

// Verify JWT token
jwt.verify(token, secretKey, (err, decoded) => {
  if (err) {
    // Token verification failed
  } else {
    const userId = decoded.userId;
    // Token verification succeeded


  1. Database Management: The backend-ico-dashboard serves as a central component for managing data related to the ICO project. It allows developers to interact with a database, such as MongoDB, to store, retrieve, and manipulate ICO-related information. By leveraging an object-document mapping (ODM) library, like Mongoose, developers can define data models, perform CRUD operations, and establish relationships between different data entities. Here’s an example code snippet demonstrating the creation of a data model using Mongoose:


const mongoose = require('mongoose');

// Define data schema
const userSchema = new mongoose.Schema({
  username: String,
  email: String,
  password: String,
  // ...

// Create a model from the schema
const User = mongoose.model('User', userSchema);

// Create a new user
const newUser = new User({
  username: 'john_doe',
  email: '',
  password: 'password123',
  // ...

// Save the user to the database
  .then(savedUser => {
    // User saved successfully
  .catch(error => {
    // Error occurred while saving the user


  1. Administrative Dashboard Functionality: The backend-ico-dashboard serves as the foundation for developing an administrative dashboard for managing the ICO project. It provides APIs and business logic to handle various administrative tasks, such as managing user accounts, generating reports, performing analytics, and configuring project settings. Developers can utilize frameworks like Express.js to define routes and controllers that handle incoming requests and execute the necessary business logic. With the backend-ico-dashboard, developers can create a feature-rich administrative interface to efficiently manage and monitor the ICO project.



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.