基于AWS部署关联Redis与MongoDB的Node.js应用步骤咨询

Hey there! Let's walk through exactly how to set up your dedicated Redis EC2 instance to pair with your existing Node.js and MongoDB servers. Since you’re going with the single-service-per-instance approach (smart move for clarity and resource isolation), here’s a step-by-step breakdown to get you up and running:

Head over to the AWS EC2 Console and start by launching a fresh instance:

• Pick an AMI: Ubuntu Server or Amazon Linux 2 both work great—Ubuntu’s usually more familiar for Node.js/MongoDB users, but go with whatever you prefer.
• Instance Type: For basic workloads or development, a t2.micro (free-tier eligible) is enough. If you expect higher traffic, bump up to t2.small or larger.
• Configure Details:
  • Make sure it’s in the same VPC as your Node.js and MongoDB instances—this lets them communicate privately, no public exposure needed.
  • Enable auto-assign public IP only if you need to SSH in for setup (you can lock this down later).
• Storage: Default 8GB is sufficient for most Redis use cases (Redis is in-memory, but persistence will use disk space—adjust if you plan heavy RDB/AOF usage).
• Tags: Add a tag like Name: Redis-Server to keep your instances organized.
• Security Group: This is critical—don’t skip these rules:
  • Allow inbound SSH access only from your IP so you can connect to the instance.
  • Allow inbound traffic on port 6379 (Redis default) only from your Node.js instance’s private IP or security group. Never open 6379 to 0.0.0.0/0 unless you have a specific reason and secure Redis with a strong password.
• Review, launch, and select your existing key pair (or create a new one if you don’t have one saved).

Use SSH to log into your new instance:

• For Ubuntu:

  ssh -i /path/to/your-key-pair.pem ubuntu@<redis-public-ip>
  

• For Amazon Linux 2:

  ssh -i /path/to/your-key-pair.pem ec2-user@<redis-public-ip>
  

On Ubuntu: #

1. Update your package lists first:

   sudo apt update
   

2. Install Redis:

   sudo apt install redis-server -y
   

3. Verify it’s running:

   sudo systemctl status redis-server
   

On Amazon Linux 2: #

1. Enable the EPEL repository (required for Redis):

   sudo amazon-linux-extras install epel -y
   

2. Install Redis:

   sudo yum install redis -y
   

3. Start Redis and set it to run on boot:

   sudo systemctl start redis
   sudo systemctl enable redis
   

4. Check its status:

   sudo systemctl status redis
   

By default, Redis only accepts local connections. Let’s adjust this so your Node.js app can connect, and lock down security:

1. Open the Redis config file:
   • Ubuntu: sudo nano /etc/redis/redis.conf
   • Amazon Linux 2: sudo nano /etc/redis.conf
2. Make these key changes:
   • Bind to private IP: Find the line starting with bind 127.0.0.1 and replace it with your Redis instance’s private IP (or 0.0.0.0 if you want to allow all private IPs in your VPC—binding to the specific private IP is more secure). Example:

     bind 10.0.1.100
     

   • Set a strong password: Find # requirepass foobared, uncomment it, and replace foobared with a secure password. Example:

     requirepass MySuperSecureRedisPass123!
     

   • Disable protected mode: Only do this if you’ve bound to a private IP and set a password. Change protected-mode yes to protected-mode no to allow external connections.
3. Save the file and restart Redis:

   # Ubuntu
   sudo systemctl restart redis-server
   # Amazon Linux 2
   sudo systemctl restart redis
   

Make sure your Node.js app can talk to Redis:

1. SSH into your Node.js EC2 instance.
2. Install the Redis client if you haven’t already:

   npm install redis
   

3. Create a quick test script (or update your existing app) to connect:

   const redis = require('redis');
   
   const client = redis.createClient({
     host: '<redis-private-ip>',
     port: 6379,
     password: 'MySuperSecureRedisPass123!'
   });
   
   client.on('connect', () => {
     console.log('Connected to Redis successfully!');
     // Test a simple set/get operation
     client.set('test_key', 'Hello from Node.js!', (err, reply) => {
       if (err) throw err;
       console.log('Set response:', reply);
       client.get('test_key', (err, value) => {
         if (err) throw err;
         console.log('Retrieved value:', value);
         client.quit();
       });
     });
   });
   
   client.on('error', (err) => {
     console.error('Redis connection error:', err);
   });
   

4. Run the script. If you get errors, double-check:
   • Your Redis security group allows port 6379 from your Node.js instance’s IP/security group.
   • Redis is bound to the correct private IP.
   • Your password is entered correctly.

If you want Redis to retain data after restarts, configure either RDB or AOF persistence:

• RDB: Takes snapshots at set intervals (already enabled by default—look for lines like save 900 1 in the config, which means save if 1 key changes in 900 seconds).
• AOF: Logs every write operation for better durability. To enable, change appendonly no to appendonly yes in the config, then restart Redis.

Choose based on your needs: RDB is more efficient, AOF offers stronger data recovery guarantees.

• You’re absolutely right about single-service-per-instance: While MongoDB and Redis can run on the same machine, separating them gives you better resource control (Redis is memory-heavy, MongoDB uses disk/CPU), easier independent scaling, and simpler monitoring.
• Security reminder: Never expose Redis to the public internet without strong auth and encryption. Using private VPC IPs is the safest approach.
• Monitoring: Set up CloudWatch alarms for CPU, memory, and disk usage on your Redis instance to keep an eye on performance.

内容的提问来源于stack exchange，提问作者joshL