DEV Community: Purvesh Panchal

Automated Deployments of Meteor.js bundle using Terraform

Purvesh Panchal — Sun, 15 Dec 2024 16:44:15 +0000

Automating Deployment on EC2 Instance with Terraform and Docker

Hey buddy! Tech can be tricky, but you’ve got this. Think of this as a tech chat over coffee...or my personal favorite, chaay (tea).

Let’s dive into how to automate deploying your Meteor.js project on AWS. By the end of this, you’ll feel like a cloud deployment ninja. Ready? Let’s go!

What You’ll Need

Before we roll up our sleeves, let’s gather our stuffff. Here's the checklist:

AWS Credentials: Ensure you have the AWS CLI configured and ready to roll.
Terraform: Download and install Terraform if you haven’t already.
SSH Key Pair: Generate an SSH key pair. Keep the private key handy to connect to your instance later.
Domain Name: Got a domain? Great! Make sure you can update its A records.
Meteor Bundle: Prep your Meteor.js project bundle using this command:

   meteor build --server-only --directory ~/path/to/Dockerfile

Setup Scripts: You’ll need three scripts to set up the server:

Got everything? Awesome! Let’s start building.

The Game Plan

Here’s the journey we’re about to go on:

Use Terraform to spin up an EC2 instance on AWS.
Run some scripts to configure the server, install MongoDB, and deploy your Meteor.js app using Docker.
Tweak your DNS settings to point your domain to the server’s IP.
Finalize everything with SSL setup via Certbot.

Easy enough, right? Let’s break it down step by step.

Setting Up Terraform

Start by organizing your Terraform project. Create a directory structure like this:

project-directory/
├── main.tf
├── variables.tf
├── outputs.tf
├── run.sh

Step 1: Variables Configuration

In variables.tf, define all the variables we’ll need. These make the setup flexible:

variable "server_name" {
  description = "Server created by Terraform"
  type        = string
  default     = "AutomatedDeployment"
}

variable "key_pair_name" {
  description = "Key pair name"
  type        = string
  default     = "tf-key-pair"
}

variable "domain_name" {
  description = "Your domain name"
  type        = string
  default     = "xyz.domain.com"
}

Step 2: The Heart — `main.tf`

Here’s where the magic happens. This file sets up everything: EC2 instance, security groups, and provisioning steps.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"
    }
  }
  required_version = ">= 1.2.0"
}

provider "aws" {
  region = "ca-central-1"
}

resource "aws_security_group" "tf-security-group" {
  name        = var.server_name
  description = "Security group for ${var.server_name}"

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_instance" "tf-created-instance" {
  ami           = "ami-0083d3f8b2a6c7a81"
  instance_type = "t2.micro"
  key_name      = var.key_pair_name
  tags = {
    Name = var.server_name
  }
}

Step 3: Outputs

Define what Terraform should output after running:

output "public_ip" {
  value       = aws_instance.tf-created-instance.public_ip
  description = "The public IP address of the instance"
}

Step 4: Automation Script

In run.sh, write a script to automate Terraform commands and handle DNS propagation:

#!/bin/bash
set -e
DOMAIN="your.domain.com"

terraform apply -auto-approve

echo "Waiting for DNS propagation..."
OLD_IP=$(dig +short $DOMAIN)
while true; do
  sleep 10
  NEW_IP=$(dig +short $DOMAIN)
  [ "$NEW_IP" != "$OLD_IP" ] && break
  echo "DNS records not updated yet. Retrying..."
done

terraform apply -auto-approve

Dockerfile for Meteor

Here’s a sample Dockerfile to package your Meteor.js app:

FROM node:14.21.3-alpine

WORKDIR /app
COPY bundle/ .
EXPOSE 3000

ENV PORT=3000 \
    ROOT_URL="http://localhost:3000" \
    MONGO_URL="<your-MongoDB-url>"

WORKDIR /app/programs/server
RUN npm install

CMD ["sh", "-c", "MONGO_URL=mongodb://user:password@${MONGO_HOST}:27017/wp node /app/main.js"]

Steps to Deploy

Initialize Terraform: Run this command to set up Terraform:

   terraform init

Deploy with Automation: Run the script to deploy:

   ./run.sh

DNS Update:
Update your domain’s A record to point to the EC2 instance’s public IP.
Verify:
Once DNS propagation is complete, verify your deployment by visiting the domain in a browser.

And there you have it! A fully automated Meteor.js app deployment on AWS using Terraform and Docker. Remember, every challenge is just another opportunity to learn. If you hit a rock, take a sip of chaay and troubleshoot like the tech pro you are. Celebrate your deployment success and post it everywhere!😉

How to Run Two MongoDB Instances on the Same Server (Standalone and Replica Set)

Purvesh Panchal — Sat, 30 Nov 2024 15:04:35 +0000

Hey buddy! Tech can be tricky, but you’ve got this. Think of this as a tech chat over coffee...or my personal favorite chaay(tea). Let’s get to it!

If you're working with MongoDB, there might come a time when you need to run two MongoDB instances on the same server—one as a standalone instance and another as part of a replica set. This guide will walk you through setting up two MongoDB instances on different ports, using separate configurations, all on the same server. By the end of this tutorial, you'll have one standalone MongoDB instance and another configured as a replica set member.

Introduction
Prerequisites
Step 1: Prepare Your Server for the Second MongoDB Instance
Step 2: Configure MongoDB to Run Two Instances on Different Ports
Step 3: Create Separate Configurations for the Second MongoDB Instance
Step 4: Start the Second MongoDB Instance
Step 5: Initialize the Replica Set
Step 6: Verify and Connect to Both MongoDB Instances
Conclusion

Introduction

Running multiple MongoDB instances on a single server can be useful for testing, staging environments, or setting up replica sets without additional hardware. But hey, it’s a little tricky! Don’t worry, though, we’ll go step-by-step and make sure everything runs smoothly. In this tutorial, you’ll learn how to:

Set up one MongoDB instance as standalone.
Set up a second MongoDB instance with a replica set.
Run both instances on different ports.
Manage data directories and log files for each instance.

Prerequisites

Before starting, just a couple of things to make sure:

You have root or sudo access to the server.
MongoDB is already installed and running as a standalone instance on your server.
You’ve got a basic understanding of MongoDB configuration and Linux commands.

Step 1: Prepare Your Server for the Second MongoDB Instance

Since you already have one MongoDB instance running, you need separate directories for the second MongoDB instance to store its data and logs.

Create a Separate Data Directory

sudo mkdir -p /var/lib/mongodb-replicaset
sudo chown -R mongodb:mongodb /var/lib/mongodb-replicaset

Create a Separate Log Directory

sudo mkdir -p /var/log/mongodb-replicaset
sudo chown -R mongodb:mongodb /var/log/mongodb-replicaset

Step 2: Configure MongoDB to Run Two Instances on Different Ports

Since MongoDB instances can’t share the same port, you'll want your standalone MongoDB running on the default port (27017), and the second instance will run on a different port, like 27018.

Step 3: Create Separate Configurations for the Second MongoDB Instance

Now, you’ll need a new mongod.conf file for the second instance.

Copy the Default MongoDB Configuration File

sudo cp /etc/mongod.conf /etc/mongod-replicaset.conf

Edit the Configuration for the Second Instance

Open the new config file /etc/mongod-replicaset.conf and tweak the following:

# mongod-replicaset.conf

# Where and how to store data.
storage:
  dbPath: /var/lib/mongodb-replicaset
  journal:
    enabled: true

# Where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: /var/log/mongodb-replicaset/mongod.log

# Network interfaces.
net:
  port: 27018  # Different port for the second instance
  bindIp: 0.0.0.0  # Listen on all IP addresses

# Enable replica set
replication:
  replSetName: rs0  # Replica set name

# Enable security and authentication if required
security:
  authorization: enabled

This configuration makes sure the second MongoDB instance runs on port 27018 and has its own directories for data and logs.

Step 4: Start the Second MongoDB Instance

Now it’s time to get the second MongoDB instance up and running. You’ll want to create a separate service for it if you're using systemd.

Copy the MongoDB Service File

sudo cp /lib/systemd/system/mongod.service /lib/systemd/system/mongod-replicaset.service

Edit the New Service File

In /lib/systemd/system/mongod-replicaset.service, change the ExecStart line to point to your new configuration file:

[Service]
ExecStart=/usr/bin/mongod --config /etc/mongod-replicaset.conf

Reload systemd and Start the Second MongoDB

sudo systemctl daemon-reload
sudo systemctl start mongod-replicaset
sudo systemctl enable mongod-replicaset

Now, your second MongoDB instance should be up and running on port 27018.

Step 5: Initialize the Replica Set

Once the second MongoDB instance is running, it's time to initialize the replica set.

Connect to the Second MongoDB Instance

mongosh --port 27018

Run the Replica Set Initialization Command

rs.initiate()

You can check the replica set status with:

rs.status()

Step 6: Verify and Connect to Both MongoDB Instances

You now have two MongoDB instances running on the same server.

Standalone Instance (Port 27017)

To connect to the standalone instance, run:

mongosh --port 27017

Replica Set Instance (Port 27018)

To connect to the replica set instance, run:

mongosh --port 27018

Conclusion

By following this guide, you've successfully set up two MongoDB instances on the same server—one as a standalone instance and the other as part of a replica set. You’ve also learned how to handle data and logs for each instance.

This approach is perfect for testing or running multiple MongoDB instances without extra hardware. You’ve got it—time to flex those MongoDB skills!

Frequently Asked Questions

1. Can I add more members to the replica set later?
Yes, you can add more members to your replica set by using the rs.add() command.

2. How can I secure the second MongoDB instance?
Make sure that both instances are secured with authentication, IP-based access control, and firewalls.

3. Can I run more than two MongoDB instances on the same server?
Yes, you can run additional MongoDB instances on the same server as long as they have separate ports, data directories, and configuration files.

4. How do I stop the second MongoDB instance?
You can stop it by running:

sudo systemctl stop mongod-replicaset

That’s all, my friend! You’ve optimally used your server resources and got a great setup to manage different environments with MongoDB.

MySQL Mayhem: How to Reset Your Root Password for MySQL in No Time!

Purvesh Panchal — Thu, 05 Sep 2024 17:50:26 +0000

Hey there, fellow MySQL wrangler! Ever been locked out of your MySQL database because the root password decided to pull a vanishing act? Or maybe it’s just not playing nice? Don’t sweat it! you’re in good company. This happens to pretty much everyone at some point. The good news? It’s an easy fix!

By the time we’re done here, you’ll be resetting that pesky root password like a seasoned pro. No more pulling your hair out — just pure MySQL mastery.

Step 1: Knock, Knock! Getting Into MySQL as Root

First thing’s first, let’s get through the front door. Fire up your terminal and hit MySQL as the root user with this command:

sudo mysql -u root

Boom! You’re in! (Hopefully... 😬 If not, we’ll save that mess for another day.) But let’s assume we’re in—because we're optimistic like that.

Step 2: Let’s Spy on the Authentication Setup

Now that you’ve got your foot in the door, it’s time to see how MySQL is handling the root user’s login. We need to know what authentication method is being used. Just run this command:

SELECT User, Host, plugin FROM mysql.user;

This will spit out some handy details—who’s logging in, from where, and, most importantly, how. It’s like a little behind-the-scenes peek at the database’s security setup. Now, based on that, we’ll choose the right path forward. Ready?

Step 3: The Password Fix—Choose Your Adventure!

Alright, now the fun begins. Depending on the authentication method you found in Step 2, here are a few different ways you can reset the root password.

Option 1: Old-School Password Authentication

If you see mysql_native_password listed as the plugin, or if you just want to stick with the classic method of login, this is the command for you:

UPDATE mysql.user SET Password = PASSWORD('your_new_password') WHERE User = 'root';
FLUSH PRIVILEGES;

Just like that, new password in place! (And don't forget to make it something you’ll actually remember this time... or use a password manager—seriously.)

Option 2: Welcome to the Future with `caching_sha2_password`

If you’re rolling with MySQL 8.0+ (or just like keeping things secure), your root user might be using caching_sha2_password. Here’s how to reset the password with the new-age encryption:

ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'your_new_password';
FLUSH PRIVILEGES;

Nice, right? Fancy encryption, modern security—everything you need to keep hackers and snoops at bay.

Option 3: A Blast from the Past—Switching Back to `mysql_native_password`

If, for some reason, you need to revert back to the old-school method (maybe an app you’re using requires it), you can switch the root user back to mysql_native_password with this command:

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'your_new_password';
FLUSH PRIVILEGES;

Nothing wrong with a little nostalgia, right? Sometimes the old ways still work best!

Step 4: Make Sure MySQL Actually Listens (Apply the Changes)

Now, after you’ve run the right command to reset the password, don’t forget to lock it in! Run this:

FLUSH PRIVILEGES;

This makes sure that MySQL actually takes those changes seriously and updates its privileges. It’s like telling MySQL, "Hey, pay attention!"

Step 5: Exit Stage Left

You’ve done the hard work—now it’s time to exit the MySQL shell. Just type:

exit;

And you’re outta there. How smooth was that?

Final Thoughts

Congrats! You’ve just wrestled MySQL into submission and reset that elusive root password. Next time, maybe note the password down somewhere safe... or, you know, use a password manager! 😏

Troubleshooting Tips: When MySQL Still Plays Hard to Get

Okay, so you’ve followed the steps, and MySQL’s still giving you the cold shoulder? Don’t panic! Here’s a little trick up your sleeve.

Problem: “Access Denied” Errors?

Sometimes, MySQL can act stubborn when you’re trying to log in, even after resetting the password. If you’re getting an “Access Denied” error, you may need to restart MySQL in safe mode.

Here’s what to do:

Stop the MySQL service by running this command in your terminal:

   sudo systemctl stop mysql

Restart MySQL in safe mode with the --skip-grant-tables option, which lets you bypass the normal login process:

   sudo mysqld_safe --skip-grant-tables &

Log in to MySQL without a password:

   mysql -u root

Reset the password using the same commands from earlier, depending on your authentication method.
Exit MySQL, and restart the service normally:

   sudo systemctl start mysql

Now, try logging in again with your new password. It should work like a charm!

Now go forth and manage your databases like the MySQL genius you are! 🎉

Step-by-Step Guide to Secure Elasticsearch with SSL Certs and Authentication

Purvesh Panchal — Fri, 23 Aug 2024 19:20:58 +0000

This detailed article will show you how to secure Elasticsearch on Ubuntu 20.04 using X-Pack and SSL/TLS encryption.

Step 1: Install your desired version of Elasticsearch

wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.15.0-amd64.deb
wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.15.0-amd64.deb.sha512
shasum -a 512 -c elasticsearch-8.15.0-amd64.deb.sha512 
sudo dpkg -i elasticsearch-8.15.0-amd64.deb

Step 2: Enable X-Pack security

sudo nano /etc/elasticsearch/elasticsearch.yml

Open the Elasticsearch configuration file for editing.
Uncomment the line xpack.security.enabled: true by removing the # at the beginning.
Save the changes and exit the text editor.

Step 3: Generate SSL certificates

sudo mkdir /etc/elasticsearch/certs
sudo apt install openssl
sudo openssl req -x509 -out /etc/elasticsearch/certs/elastic1.crt -keyout /etc/elasticsearch/certs/elastic1.key -newkey rsa:2048 -nodes -sha256 -subj "/C=US/ST=State/L=Location/O=Organization/OU=Organizational Unit/CN=localhost"
sudo openssl pkcs12 -export -in /etc/elasticsearch/certs/elastic1.crt -inkey /etc/elasticsearch/certs/elastic1.key -out /etc/elasticsearch/certs/elastic1.p12 -name "elasticsearch-cert"
sudo chown -R elasticsearch:elasticsearch /etc/elasticsearch/certs
sudo chmod 0400 /etc/elasticsearch/certs/*

This step generates a self-signed SSL certificate using OpenSSL and converts it to PKCS#12 format.

Step 4: Configure SSL settings

sudo nano /etc/elasticsearch/elasticsearch.yml

Open the Elasticsearch configuration file for editing.
Add the following lines at the end of the file to configure SSL settings:

xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.keystore.path: /etc/elasticsearch/certs/elastic1.p12
xpack.security.transport.ssl.truststore.path: /etc/elasticsearch/certs/elastic1.p12

Save the changes and exit the text editor.

Step 5: Restart Elasticsearch

sudo systemctl restart elasticsearch

This step restarts Elasticsearch to apply the configuration changes.

Step 6: Verify SSL/TLS encryption

curl --cacert /etc/elasticsearch/certs/elastic1.p12 https://localhost:9200

This command tests the SSL/TLS connection using curl to verify that the SSL/TLS encryption is working properly.

Step 7: Configure user authentication and roles

sudo /usr/share/elasticsearch/bin/elasticsearch-setup-passwords auto

This step sets the password for the built-in elastic user. Make sure to save the generated password.
Configure additional users and roles as needed using the elasticsearch-users command.

Step 8: Update firewall rules

If you have a firewall enabled, allow incoming connections to the Elasticsearch port (default: 9200) and SSL/TLS port (default: 9300) to ensure external access.
For example, using ufw firewall:

sudo ufw allow 9200/tcp
sudo ufw allow 9300/tcp

Adjust the commands based on your specific firewall configuration.

By following these steps, you should be able to secure Elasticsearch using X-Pack with SSL/TLS encryption on Ubuntu 20.04. Remember to adjust any file paths or configurations according to your specific requirements.

How to Configure a 3-Node MongoDB 6 Replica Set: Tested Step-by-Step Guide

Purvesh Panchal — Sat, 10 Aug 2024 15:53:11 +0000

Prerequisites

Before setting up the MongoDB 6.0.10 replica set, ensure you have completed the following prerequisites:

Step 1: Install MongoDB 6.0.10

Install MongoDB 6.0.10 using the provided script:

# Install required packages
sudo apt-get install gnupg curl -y

# Import the MongoDB public GPG Key
curl -fsSL <https://pgp.mongodb.com/server-6.0.asc> | \\
   sudo gpg -o /usr/share/keyrings/mongodb-server-6.0.gpg \\
   --dearmor

# Create a list file for MongoDB
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-6.0.gpg ] <https://repo.mongodb.org/apt/ubuntu> jammy/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list

# Update package list and install MongoDB
sudo apt-get update
sudo apt-get install mongodb-org -y

Step 2: Add Hosts and Configure Server Hostnames

Add the hostnames and IP addresses of all three servers to the /etc/hosts file on each server. Use this example as a reference:

192.168.1.21 primary.mongo
192.168.1.22 secondary1.mongo
192.168.1.23 secondary2.mongo

Step 3: Test Hostname Resolution

Ping each server from every other server using their hostnames to verify hostname resolution.

Example:

ping primary.mongo
ping secondary1.mongo
ping secondary2.mongo

Step 4: Create Admin User (If Not Enabled)

If you didn't enable authentication during MongoDB installation, create an admin user.

Example:

# Connect to MongoDB using the MongoDB shell
mongosh --host <Hostname or IP of each>:27017

# Switch to the admin database
use admin

# Create an admin user with appropriate roles
db.createUser({
    user: "admin",
    pwd: "your_password",
    roles: [
        "userAdminAnyDatabase",
        "dbAdminAnyDatabase",
        "readWriteAnyDatabase",
        "root"
    ]
})

Replace "your_password" with a secure password for the admin user.

Step 5: Enable Security with Keyfile

Generate a key and store it at /etc/mongodb/keys/mongo-key,
Just copy & paste the below command on all three servers:

sudo openssl rand -base64 756 > /etc/mongodb/keys/mongo-key
sudo chmod 600 /etc/mongodb/keys/mongo-key

Step 6: Restart MongoDB and Check Status

Restart MongoDB on all servers and check the status:

sudo service mongod restart
sudo service mongod status

Step 7: Test Connectivity (Optional)

mongosh -u "admin_username"

Let's begin with ReplicaSet Configuration

Now proceed with the main setup steps:

Step 1: Update MongoDB Configuration Files

On each server, update the MongoDB configuration file /etc/mongod.conf with the provided example:

storage:
  dbPath: /opt/mongodb

systemLog:
  destination: file
  logAppend: true
  path: /var/log/mongodb/mongod.log

net:
  port: 27017
  bindIp: 0.0.0.0

processManagement:
  timeZoneInfo: /usr/share/zoneinfo
  fork: true

security:
  authorization: enabled
  keyFile: /etc/mongodb/keys/mongo-key
  transitionToAuth: true

replication:
  replSetName: rs111

Step 2: Start MongoDB on Each Server

Start MongoDB on each server using the following command:

sudo service mongod start
sudo service mongod status

Step 3: Connect to Primary's Mongo Shell (mongosh or mongo)

Connect to one of the MongoDB servers using the MongoDB shell (mongosh).

Example:

mongosh --host server_ip:27017

Replace server_ip with the IP address of the server you want to connect to.

Step 4: Initialize the Replica Set

Inside the MongoDB shell, initialize the replica set with the chosen name (rs111). Run this command on the server you want as the primary.

Example:

rs.initiate({
  _id: "rs111",
  members: [
    { _id: 0, host: "primary.mongo:27017" },
    { _id: 1, host: "secondary1.mongo:27017" },
    { _id: 2, host: "secondary2.mongo:27017" }
  ]
})

Replace primary_hostname, secondary1_hostname, and secondary2_hostname with the hostnames of your servers. The primary should be the server where you run this command.

Step 5: Verify Replica Set Status

Verify the status of the replica set by running the following command in the MongoDB shell:

rs.status()

To check the status of replicaSet

Troubleshooting Common Issues & Notes

Issue 1: "no reachable/healthy members" or "STARTUP" state

Solution: If you encounter these issues, it means that one or more replica set members are not reachable or are still in the startup process. Check network connectivity, MongoDB status, and logs.
```
sudo less /var/log/mongodb/mongod.log
```
Solution: Check /etc/hosts in each server, are all three hostnames added and are they using correct IP Addresses.
```
192.168.1.21 primary.mongo
192.168.1.22 secondary1.mongo
192.168.1.23 secondary2.mongo
```
Solution: If nothing works reconfigure replicaSet using correct IP Addresses.

Connect to the primary node of your replica set using the mongo shell:

       mongo --host primary_ip:27017

Replace primary_ip with the IP address of your primary node.

In the mongo shell, execute the following command to obtain the current replica set configuration:

        var cfg = rs.conf()

This command stores the current replica set configuration in the cfg variable.

Edit the cfg variable to update the hostnames with their respective IP addresses. You will need to modify the host field for each member in the configuration.

For example:

        cfg.members[0].host = "192.168.1.21:27017";
        cfg.members[1].host = "192.168.1.22:27017";
        cfg.members[2].host = "192.168.1.23:27017";

Replace primary_ip, secondary1_ip, and secondary2_ip with the actual IP addresses and port numbers for your servers.

After making the necessary changes, reconfigure the replica set using the updated cfg variable:

        rs.reconfig(cfg)

This command will apply the modified configuration to the replica set.

To ensure that the changes are applied successfully, you can check the replica set status using:

        rs.status()

Verify that the hostnames have been updated with the correct IP addresses in the replica set configuration.

Make sure to execute these commands carefully and replace the placeholders with your actual server IP addresses and port numbers.

Issue 2: Authentication Errors

Solution: If you encounter authentication errors, ensure valid credentials are provided when connecting to MongoDB. Verify user privileges, or check if you’ve created an admin user in secondary servers.

Additional Notes:

Use 0.0.0.0 for bindIp only if you've enabled authentication by adding an admin user in the admin database of all MongoDB instances.
You can change default “dbPath: /var/lib/mongodb” or choose a different path like “dbPath: /opt/mongodb” in mongod.conf file.

Attended Community Meetup by Infinity AI

Purvesh Panchal — Sun, 25 Jun 2023 15:27:45 +0000

Yesterday, I did something I hadn't done in a long time: I attended a community event! And I'm happy that I did. It was "Community Meetup" by Infinity AI(Learn and grow together) , that provided a great overview of the field of AI and ML.

Mr. Bhargav Patel was the first speaker to provide his thoughts on AI-ML, LLMs, and MLOps. As a DevOps Engineer, I knew I had to put everything I had learned to use. That was just the start!

But the learning didn't stop there! Mr. Preyan Mehta Mehta, the second speaker, gave us with insights into the world of Generative AI and Democratically Smart People. It was fascinating to see how AI can help us improve our workflows and optimise processes in this ever-changing world of tech!

But the highlight of the event was the AI-ML quiz. Out of 53 participants, I came in first place and received this adorable little plant as a prize. 🏆🪴

All in all, it was an incredible experience that left me feeling inspired and motivated to continue learning and growing in the field of AI & ML.

However, the best part of the event was connecting with other members of the community and learning about upcoming events. It's always great to network with like-minded individuals and share ideas and experiences.

TL;DR

Attended the "Community Meetup" event by Infinity AI(Learn and grow together)
Bhargav Patel spoke about AI-ML, LLMs, and MLOps
Preyan Mehta Mehta shared insights on Generative AI and Democratically Smart People
Won first place in the AI-ML quiz and received a cute plant as a prize
Left feeling inspired and motivated to continue my learning in AI
Interested in hearing about others' impactful community event experiences

Have you attended any community events lately that have left a lasting impact on you? Let's start a discussion in the comments below! #InfinityAI #AI #ML #GenerativeAI #CommunityEvents #Networking #DevOps #MLOps #Learning

DEV Community: Purvesh Panchal

Automated Deployments of Meteor.js bundle using Terraform

Automating Deployment on EC2 Instance with Terraform and Docker

What You’ll Need

The Game Plan

Setting Up Terraform

Step 1: Variables Configuration

Step 2: The Heart — main.tf

Step 3: Outputs

Step 4: Automation Script

Dockerfile for Meteor

Steps to Deploy

How to Run Two MongoDB Instances on the Same Server (Standalone and Replica Set)

Table of Contents

Introduction

Prerequisites

Step 1: Prepare Your Server for the Second MongoDB Instance

Create a Separate Data Directory

Create a Separate Log Directory

Step 2: Configure MongoDB to Run Two Instances on Different Ports

Step 3: Create Separate Configurations for the Second MongoDB Instance

Copy the Default MongoDB Configuration File

Edit the Configuration for the Second Instance

Step 4: Start the Second MongoDB Instance

Copy the MongoDB Service File

Edit the New Service File

Reload systemd and Start the Second MongoDB

Step 5: Initialize the Replica Set

Connect to the Second MongoDB Instance

Run the Replica Set Initialization Command

Step 6: Verify and Connect to Both MongoDB Instances

Standalone Instance (Port 27017)

Replica Set Instance (Port 27018)

Conclusion

Frequently Asked Questions

MySQL Mayhem: How to Reset Your Root Password for MySQL in No Time!

Step 1: Knock, Knock! Getting Into MySQL as Root

Step 2: Let’s Spy on the Authentication Setup

Step 3: The Password Fix—Choose Your Adventure!

Option 1: Old-School Password Authentication

Option 2: Welcome to the Future with caching_sha2_password

Option 3: A Blast from the Past—Switching Back to mysql_native_password

Step 4: Make Sure MySQL Actually Listens (Apply the Changes)

Step 5: Exit Stage Left

Final Thoughts

Troubleshooting Tips: When MySQL Still Plays Hard to Get

Problem: “Access Denied” Errors?

Step-by-Step Guide to Secure Elasticsearch with SSL Certs and Authentication

This detailed article will show you how to secure Elasticsearch on Ubuntu 20.04 using X-Pack and SSL/TLS encryption.

How to Configure a 3-Node MongoDB 6 Replica Set: Tested Step-by-Step Guide

Prerequisites

Step 1: Install MongoDB 6.0.10

Step 2: Add Hosts and Configure Server Hostnames

Step 3: Test Hostname Resolution

Step 4: Create Admin User (If Not Enabled)

Step 5: Enable Security with Keyfile

Step 6: Restart MongoDB and Check Status

Step 7: Test Connectivity (Optional)

Let's begin with ReplicaSet Configuration

Step 1: Update MongoDB Configuration Files

Step 2: Start MongoDB on Each Server

Step 3: Connect to Primary's Mongo Shell (mongosh or mongo)

Step 4: Initialize the Replica Set

Step 5: Verify Replica Set Status

Troubleshooting Common Issues & Notes

Issue 1: "no reachable/healthy members" or "STARTUP" state

Issue 2: Authentication Errors

Additional Notes:

Attended Community Meetup by Infinity AI

TL;DR

Step 2: The Heart — `main.tf`

Option 2: Welcome to the Future with `caching_sha2_password`

Option 3: A Blast from the Past—Switching Back to `mysql_native_password`