Verify if my node.js instance is dev or production

问题

Right now, whenever I want to deploy a node.js server to my production server, I need to change all the IP/DNS/username/password for my various connection to my databases and external APIs.

This process is annoying, is there a way to verify if the currently running node.js instance is in cloud9ide or actually my production joyent smartmachine?

If I am able to detemrine (in my running code) on which server my node.js instance is running , I'll add a condition that set the values to the prod or dev.

Thank you

回答1:

Normally you should run a node app in production like this:

NODE_ENV=production node app.js

Applications with Express, Socket.IO and other use process.env.NODE_ENV to figure out the environment.

In development you can omit that and just run the app normally with node app.js.

You can detect the environment in your code like this:

var env = process.env.NODE_ENV || 'dev';
loadConfigFile(env + '.json', doStuff);

Resources:

How do you detect the environment in an express.js app?

回答2:

I think the easiest way to set the environment is to pass command-line argument to your application.

node ./server.js dev

In your script you need to handle this argument and set configuration what you need for it.

var env = process.argv[2] || 'dev';
switch (env) {
    case 'dev':
        // Setup development config
        break;
    case 'prod':
        // Setup production config
        break;
}

Also, i was created module that makes the configuration process a bit easier. Maybe it will help you.

回答3:

Actually, I would not recommend to store configuration values like database connection information, passwords, access tokens and such inside of actual application code for the following reasons:

Hardcoding those values make it difficult to change them later on. You will have to release a new version of the application to change those values.
This is a serious security violation, because production-grade configuration data and passwords shouldn't be stored in code. It's very easy to leak this sensitive data.

The better approach would be to externalize this data and pass it to your application during execution. This is normally done by means of environment variables. You just need to define unique environment variable for each peace of data that needs to be changeable between different environments.

For example: DB_HOST, DB_USER, DB_PASSWORD. Then you could pass those values to you app in production this way:

$ NODE_ENV=production DB_HOST=1.2.3.4 DB_USER=someusername DB_PASSWORD=somerandompassword /bin/node app.js

Actually, this values could be encrypted and added to the codebase and then decrypted during the deployment. However, make sure that decryption key is stored securely in deployment system or provided interactively by the release engineer. Shippable allows to do this out of the box.

In the development environment it gets simpler, because you can use very convenient dotenv module. Just create a .env file in your project's root directory and add all variables to it:

DB_HOST=1.2.3.4
DB_USER=someusername
DB_PASSWORD=somerandompassword

But, make sure to exclude it from you VCS, because each developer probably would want to have personal configuration. You can create a .env.dist file to contain default configuration, which later could be used as a template: cp .env.dist .env.

Also, I've implemented a reusable module, which allows to automatically detect environment by analyzing both CLI arguments and NODE_ENV variable. This could be useful on your development machine, because you can easily change environment by passing a CLI argument to you Node.js program like this: $ node app.js --prod. It's also nice to use with Gulp: $ gulp build --prod.

Please see more details and use cases on the detect-environment's page.