DEV Community: richard ndemo

Building CloudRegNotify: An AWS-Based User Registration and Notification System

richard ndemo — Sun, 27 Oct 2024 06:41:14 +0000

In today's digital age, user registration and notification systems play a critical role in enhancing user experience and engagement. I embarked on a journey to create CloudRegNotify, a scalable cloud-based system leveraging various AWS services to automate user sign-up, verify email addresses, store user data securely, and send notifications. This project not only challenged my skills but also deepened my understanding of cloud architecture.

Project Overview

The primary goal of CloudRegNotify was to build an efficient system that simplifies user registration while ensuring data security and scalability. By automating the user sign-up process and utilizing AWS services, I aimed to create a seamless experience for users.

Architecture

To achieve this, I designed the architecture of CloudRegNotify to incorporate the following AWS services:

AWS Cognito: For user authentication and management.
AWS Lambda: To handle the user registration logic and backend processing.
DynamoDB: For securely storing user information.
Amazon SNS: To send email notifications to users.

Implementation Steps
The implementation process was divided into several key steps, each presenting unique challenges.

Step 1: Creating a Cognito User Pool

I started by creating a user pool in the AWS Cognito console, configuring it to require both an email and a username for sign-in while enabling email verification. Ensuring the correct configuration of the user pool was crucial, as any oversight could lead to significant issues later.

Step 2: Setting Up DynamoDB
Next, I created a DynamoDB table named "UserPreferences" to store user data. Initially, I faced challenges designing an efficient table schema but opted for a straightforward structure for this Minimum Viable Product (MVP).

Step 3: Configuring SNS
To send notifications, I created an SNS topic called "UserNotifications." Configuring permissions for Lambda to interact with SNS was initially tricky, but I managed to troubleshoot and resolve the issues.

Step 4: Lambda Function Creation
I developed a Lambda function named "NotificationHandler" using Python. Writing the logic for storing user details in DynamoDB and triggering SNS notifications required several iterations, especially when I encountered permission errors. Updating the execution role with the correct policies resolved these issues.

import json
import boto3
import logging

# Initialize logging
logging.basicConfig(level=logging.INFO)

# Initialize DynamoDB and SNS clients
dynamodb = boto3.resource('dynamodb')
sns = boto3.client('sns')

def lambda_handler(event, context):
    logging.info("Received event: %s", json.dumps(event))

    try:
        user_id = event['userName']
        email = event['request']['userAttributes']['email']

        logging.info(f"User confirmed: {user_id}, Email: {email}")

        # Access DynamoDB Table
        table = dynamodb.Table('UserPreferences')

        # Store user details in DynamoDB
        table.put_item(
            Item={
                'UserID': user_id,
                'Email': email,
                'NotificationPreference': 'Email'
            }
        )
        logging.info("User details saved to DynamoDB")

        # Subscribe the user's email to the SNS topic
        try:
            sns.subscribe(
                TopicArn='arn:aws:sns:us-east-1:867093160463:UserNotifications',  # Replace with your SNS Topic ARN
                Protocol='email',
                Endpoint=email
            )
            logging.info(f"User {email} subscribed to SNS topic")
        except Exception as sub_error:
            logging.error(f"Error subscribing user {email} to SNS topic: {str(sub_error)}")
            # You can choose to continue or return here if you don't want the process to continue.
            # return event

        # Send notification via SNS
        message = f"Hello {user_id}, your account has been successfully created!"
        response = sns.publish(
            TopicArn='arn:aws:sns:us-east-1:867093160463:UserNotifications',  # Replace with your SNS Topic ARN
            Message=message,
            Subject="Account Created"
        )
        logging.info("SNS publish response: %s", response)

        # Return the event as required by Cognito Post Confirmation trigger
        return event

    except Exception as e:
        logging.error("Error occurred: %s", str(e))
        return {
            'statusCode': 500,
            'body': json.dumps(f"An error occurred: {str(e)}")
        }

Functionality

Once the setup was complete, I rigorously tested the system to ensure its functionality:

User Registration: Users can register with their email and username.
Email Verification: A verification code is sent to users, and upon confirmation, their details are securely stored in DynamoDB.
Notification: A welcome email is sent via SNS once the account is created.

AWS Services Used

The successful implementation of CloudRegNotify relied on several AWS services:

AWS Cognito
AWS Lambda
DynamoDB
Amazon SNS

Challenges and Solutions

Throughout the project, I faced various challenges, including:

Setting Permissions: Figuring out why my Lambda function couldn’t publish to SNS or write to DynamoDB was frustrating. I resolved this by attaching the necessary policies, enabling seamless interaction between services.
Handling Event Errors: ** I encountered issues with subscriptions to the SNS topic due to invalid email addresses. By enhancing error logging, I ensured that invalid emails wouldn’t disrupt the entire process.
**Testing: Comprehensive testing revealed multiple bugs, such as notifications not triggering correctly. Leveraging AWS CloudWatch logs proved invaluable for debugging.

Future Improvements

Reflecting on this project, I have identified several enhancements I plan to implement:

User Preferences: Allow users to select their preferred notification method (email, SMS, or push notifications).
Improved Error Handling: Develop more robust mechanisms to handle edge cases, particularly during user subscriptions.
Analytics: Introduce analytics to track user engagement with notifications, providing insights for improving user experience.

Conclusion

Building CloudRegNotify has been a rewarding learning experience. By leveraging AWS services like Lambda, Cognito, DynamoDB, and SNS, I created a scalable, cloud-based solution for user registration and notifications. The challenges I encountered allowed me to deepen my understanding of AWS, and I am proud of the system I developed.

You can explore the project further on GitHub.

IT ASSET MANAGEMENT -bare basics

richard ndemo — Wed, 01 Jun 2022 06:45:22 +0000

IT assets, what are they, how do they end up in your organization/company and how do you manage them for better perfomance and produtivity? .-IT asset is a peae of software/hardware within an IT echo system.
As an IT custodian, it is your responsibility to ensure the existing assets are useful and valuable to the organization.

ITAM is a business process to ensure that IT assets are acounted for, intergrated, maintained/upgraded and desposed effectively.

ITAM process involves five key phases:

planning
Developing/Acquiring
Integration
Maintenance/upgrade
Disposal

plannig

This is the begining phase of introduing an asset to the echosystem. It involves strategic planning across the organization to determine what asset is needed, how to procure it, the specific way it will be used and how it will be funded. This often includes total cost of ownership estimates and a cost-benefit analysis of alternatives.

Developing/Acquiring

After planning and knowing the right asset that is needed, the next phase is the procument in which the organization build, purchase, lease or license the asset they need.

Integration

This follow the procurement phase. During which the asset is introduced into the ecosystem of the organization.It includes intergrating the asset with other components, establishing support and operations processes and specifying user access.

Maintenance/upgrade

Once the asset is fully intergrated in the echosystem and is being utilised, to maximize its value and extend its life as well as mitigate risk and reduce support costs, maintenance, repair and extensive overhauls may be necessary.

Disposal

When the asset reaches the end of its useful life, the last phase is disposal. This includes transitioning users to other resources, updating asset records, canceling support agreements, terminating licences renewals and initiating the planning for replacement asset.

proper understanding and utilization of this phases will enable a smooth running of the IT echosystem .

How I deployed my Django app to Vultr VPS

richard ndemo — Sun, 29 Sep 2019 15:44:25 +0000

Having developed my Django app, it was time to deploy it so that it can be live, such a thrilling feeling to have my own hosted website online. - I did a couple of searches and decided to host with vultr VPS. Let us jump to the whole process from setting up my server to actual running my website.

Creating a New Instance

I chose cloud compute:

Selecting the region for my server:

selecting server operating system:

Selecting the size of the server:

I chose to name the server Testserver for a practical purpose.

after creating the server:

after receiving the root password via email, I ssh into the server using the server IP Address.

Updating the server

First thing is to upgrade the server's packages:

apt-get update apt-get upgrade



######Creating Application User
It is always best practice not to work directly with the root user.so I created another user.

<code> adduser django</code>


since I am deploying a Django application, It is simple to use a simple name.
This is the output. There are few questions to be answered.
~~~
Adding user `django' ...
Adding new group `django' (1000) ...
Adding new user `django' (1000) with group `urban' ...
Creating home directory `/home/django' ...
Copying files from `/etc/skel' ...
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
Changing the user information for urban
Enter the new value, or press ENTER for the default
  Full Name []:
  Room Number []:
  Work Phone []:
  Home Phone []:
  Other []:
Is the information correct? [Y/n]
~~~

Adding the user to sudoers to be able to perform root functions:
<code>gpassword -a django sudo</code>

Now log in to the new user account.

##Installing the necessary Dependencies:

#####Supervisor
This will be used to start the Django application server and manage it.

<code>sudo apt-get install supervisor</code>

######Starting and enabling the supervisor:

sudo systemctl enable supervisor
sudo systemctl start supervisor



#####PostgreSQL 

Installing the dependencies to be used by Postgresql and Django

<code>sudo apt-get install build-essential libpq-dev python-dev</code>

######Installing PostgreSQL server:

<code>sudo apt-get -y install postgresql postgresql-contrib</code>

######Creating and Configuring PostgreSQL database:

#####Switch users:

<code>su - postgres</code>

Creating a db user and database:

createuser django_project
createdb prod --owner django_project
psql -c "ALTER USER u_urban WITH PASSWORD '!@#fs_877#$cdfd@@'"



######exit the postgreSQL user:
<code>exit</code>

####Install and Configure Virtualenv

I used python3 that is already installed in ubuntu 16.04

######First, install pip3:

<code>sudo apt-get install python3-pip</code>

######Using pip install virtualenv:

<code>pip3 install virtualenv</code>

######Then create virtualenv:

<code>python3 -m venv django_env</code>

######Activating it:
cd to the virtualenvdirectory <code>cd django_env</code>

<code>source bin/activate</code>

I used GitHub to store my Django website, so I cloned it from the git repository.

<code>git clone https://github.com/ndemo-richard/django_project.git</code>

cd into project directory and install project dependencies:

<code>pip install -r requirements.txt</code>

changing the database credentials in the settings.py file in the project root directory:

~~~
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'prod',
        'USER': 'django_project',
        'PASSWORD': '!@#fs_877#$cdfd@@',
        'HOST': 'localhost',
        'PORT': '',
    }
}
~~~

#####migrating the database:
<code>python manage.py migrate</code>

#####collect project static files:
<code>python manage.py collectstatic</code>

####Install and configure Gunicorn

<code>pip install gunicorn</code>

create a file named gunicorn inside bin directory

<code> vi bin/gunicorn</code> 
add this to the empty file:

~~~
#!/bin/bash

NAME="django_project"
DIR=/home/django/django_project
USER=django
GROUP=django
WORKERS=3
BIND=unix:/home/django/run/gunicorn.sock
DJANGO_SETTINGS_MODULE=django_project.settings
DJANGO_WSGI_MODULE=django_project.wsgi
LOG_LEVEL=error

cd $DIR
source ../bin/activate

export DJANGO_SETTINGS_MODULE=$DJANGO_SETTINGS_MODULE
export PYTHONPATH=$DIR:$PYTHONPATH

exec ../bin/gunicorn ${DJANGO_WSGI_MODULE}:application \
  --name $NAME \
  --workers $WORKERS \
  --user=$USER \
  --group=$GROUP \
  --bind=$BIND \
  --log-level=$LOG_LEVEL \
  --log-file=-
~~~

make the file executable

<code>chmod u+x bin/gunicorn</code>

create directory for the UNIX socket file:

<code> mkdir run</code>

#####Configure Supervisor

 first, create a directory for log files:

<code>mkdir logs</code>

######Create an empty log file inside the log directory:

<code>touch logs/gunicorn-error.log</code>

create a new supervisor config file:

<code>sudo vi /etc/supervisor/conf.d/django_project.conf</code>

django_project.conf

~~~
[program:django_project]

command=/home/django/django_project/bin/gunicorn
user=urban
autostart=true
autorestart=true
redirect_stderr=true
stdout_logfile=/home/django/logs/gunicorn-error.log


Reread the config file:


```

sudo supervisorctl reread
sudo supervisorctl update

```


Check the status:

```

sudo supervisorctl status django_project
django_project                      RUNNING   pid 42173, uptime 0:00:13

```



##NGINX

Installing Nginx web server, this will be used to run the Django application behind a proxy server

<code>sudo apt-get install nginx</code>

create new config file inside /etc/nginx/sites-available/:

<code>sudo vim /etc/nginx/sites-available/django_project</code>

/etc/nginx/sites-available/djago_project

upstream app_server {
server unix:/home/urban/run/gunicorn.sock fail_timeout=0;
}

server {
listen 80;

# add here the ip address of your server
# or a domain pointing to that ip (like example.com or www.example.com)
server_name 68.152.87.135;

keepalive_timeout 5;
client_max_body_size 4G;

access_log /home/urban/logs/nginx-access.log;
error_log /home/urban/logs/nginx-error.log;

location /static/ {
    alias /home/urban/static/;
}

# checks for static file, if not found proxy to app
location / {
    try_files $uri @proxy_to_app;
}

location @proxy_to_app {
  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  proxy_set_header Host $http_host;
  proxy_redirect off;
  proxy_pass http://app_server;
}

}


creating a symbolic link:



```

sudo ln -s /etc/nginx/sites-available/django_project /etc/nginx/sites-enabled/django_project

```




Remove the default nginx website:
<code>sudo rm /etc/nginx/sites-enabled/default</code>

Restart nginx:
<code>sudo service nginx restart</code>

Now we are good to go. My website is online.