DEV Community: Ebenezer Lamptey

I Built a Real-Time Stock Price Tracker with Django, Redis and WebSockets

Ebenezer Lamptey — Sat, 14 Feb 2026 22:46:44 +0000

I wanted to have a a niche in backend engineering and i was drawn to real-time systems. I wanted understand how real-time systems actually work under the hood not just use them, but build one myself. So I built a stock price tracker that fetches live prices every 60 seconds, calculates SMAs, detects crossover alerts, and pushes everything to connected clients over WebSocket.

Here's what I learned.

What it does

Every 60 seconds:

Fetches live prices for 15 stocks from Finnhub API
Saves them to PostgreSQL
Caches the last 5 prices per stock in Redis
Calculates a 5-period SMA from the cache
Detects bullish/bearish crossover alerts
Broadcasts everything to connected WebSocket clients in one message

The stack

Django + DRF
Celery + Celery Beat (task scheduling)
Redis (caching + Channels backend)
Django Channels (WebSocket)
Uvicorn (ASGI server)
Finnhub API
SQLite for db since i was having issues with postgreql on my mac

The part that clicked for me: Redis could be used for other stuff and I also realized how DSA is very important when I had to implement redis-list.

I had used Redis quite a few times in other projects (mostly as a broker in a message queue that is Celery for background tasks.) but i was exposed to it's other capabilities. I had already watched videos and hearing Redis is for caching but I hadn't implemented one myself.

In this project Redis is doing three different jobs:

1. Celery broker — passes tasks between Celery Beat and the worker

2. Price cache — stores the last 5 prices per stock as a Redis List

3. Channel Layer backend — lets Celery talk to Django Channels to broadcast WebSocket messages

Same Redis instance, three completely different purposes. That was a lightbulb moment.

How the caching works

Each stock has a Redis List that holds its last 5 prices. On every update I use two commands:

RPUSH stock:AAPL:prices 255.78   → add new price to the end
LTRIM stock:AAPL:prices -5 -1    → remove anything older than last 5

That's it. The list always has a maximum of 5 items and the oldest price falls off automatically.

I also used Redis pipelines to batch these commands together. Instead of making separate round-trips to Redis for each stock, I queue all the commands and execute them in one go. With 15 stocks that's the difference between 60 round-trips and 2.

How the SMA and alerts work

Once 5 prices are cached, calculating SMA is just:

sma = sum(last_5_prices) / 5

For alerts I compare the previous price against the previous SMA, and the current price against the current SMA. If the price crossed the line between those two readings, that's a crossover:

# Bullish: price was below SMA, now above
if previous_price < previous_sma and current_price > current_sma:
    alert = "bullish"

# Bearish: price was above SMA, now below
if previous_price > previous_sma and current_price < current_sma:
    alert = "bearish"

You need the previous values to detect a crossing. That's why caching the SMA matters so you have something to compare against next time.

How real-time broadcasting works

This was the trickiest part to understand. Celery and Django are separate processes. How does a background task push a message to a connected WebSocket client?

The answer is the Channel Layer.

Celery task finishes processing
        ↓
Publishes message to Channel Layer (Redis)
        ↓
Django Channels picks it up
        ↓
Pushes to all connected WebSocket clients

Redis is the bridge between the two processes. Celery writes to it, Channels reads from it.

The WebSocket message looks like this:

{
    "type": "stock_update",
    "timestamp": "2026-02-14T21:38:22+00:00",
    "stocks": [
        { "ticker": "AAPL", "price": 255.78, "sma": 254.32, "alert": null },
        { "ticker": "MSFT", "price": 401.32, "sma": 399.80, "alert": "bullish" },
        { "ticker": "TSLA", "price": 417.44, "sma": 419.10, "alert": "bearish" }
    ]
}

All 15 stocks in one message, every 60 seconds, automatically.

Running two servers in development

One thing that tripped me up was Django's runserver doesn't support WebSockets. It was a struggle. It's a WSGI server, which is request/response only. WebSockets need a persistent connection, so you need an ASGI server.

I run both during development:

# For the DRF browsable API
python manage.py runserver        # port 8000

# For WebSocket connections
uvicorn core.asgi:application --port 8001

REST endpoints on 8000, WebSocket on 8001.

What I actually learned

Going in I knew Django and had used Redis a little. Coming out I understand:

How background task scheduling works with Celery Beat
How Redis Lists work and why they're perfect for rolling windows of data
What Redis pipelines are and why batching matters
The difference between WSGI and ASGI
How Django Channels uses a Channel Layer to bridge async and sync code
How to structure a real-time data pipeline end to end

Building this made real-time systems a lot less mysterious. It's not magic — it's just a producer, a channel, and a consumer.

Source code

GitHub: Stock-Price-Tracker-API

Future plans

Simple frontend to show how it works
Making sure API calls are not made when market closes. This should be done automatically.
Migrate database to PostgreSQL

Building and Dockerizing a Django To-Do List API – My First Real Backend Project!

Ebenezer Lamptey — Fri, 27 Jun 2025 13:49:39 +0000

Creating my first full Django backend project from scratch was both exciting and eye-opening. I built a To-Do List API, added PostgreSQL, containerized the entire application with Docker.

This blog post documents that journey; lessons learned, hurdles faced, and how I overcame them. If you're a beginner backend developer or looking to dip your feet into Docker and Django, I hope this post inspires and helps you!

Project Goal: Build a Simple Yet Scalable To-Do List API

The idea was to build a lightweight RESTful To-Do List API using Django and Django REST Framework (DRF). Features included:

User registration and login with access/refresh tokens
Secure authentication with JWT
Users can only access and manage their own tasks
CRUD operations on tasks
Mark tasks as completed (Boolean toggle)
Search, filter, and order support
Switched from SQLite to PostgreSQL
Docker support for consistent setup

Note: Deployment is a planned next step. This project has not yet been deployed.

Step-by-Step Journey

Building the API with Django + DRF

I started with Django and Django REST Framework, setting up views, serializers, and models to handle ToDo objects on a per-user basis. Also worked on urls. register it in admin.py; an in-built admin page for Django.

Integrating JWT Authentication
Using SimpleJWT, I added token-based authentication, allowing users to securely interact with their own tasks.
Swapping SQLite for PostgreSQL
SQLite was fine initially, but PostgreSQL better reflects real-world apps, especially when containerizing. Before i did that i had to save keys and important information in an env file to avoid commit keys and secrets to the repository. This is for security purposes.

Containerizing with Docker I wrote a Dockerfile, .dockerignore, and docker-compose.yml to package both the Django app and PostgreSQL database.

Key learnings:

Why we don't use virtual environments in containers
Setting up environment variables properly
Troubleshooting docker-compose issues

Testing Locally Using:

docker-compose up --build

I run into an issue where the database wasn't migrated. so I had to run the following commands to make the API work.

docker exec -it django-docker python /TDL/manage.py migrate
docker exec -it django-docker python /TDL/manage.py createsuperuser

createsuperuser was for admin access.

I tested the API endpoints through the container and ensured they worked with the PostgreSQL service.

What’s Next?

I explored deployment on Render using a Docker-based service. Though I didn’t complete deployment (since free tier ends soon), I now understand what it takes to deploy to production.

Planning to finalize and deploy this soon.

Reflection

This journey wasn’t just about building an API. It was about preparing to scale, containerize, and potentially deploy. I hit some roadblocks with .env handling, database permissions, and YAML formatting, but those were key moments in learning real backend + DevOps skills.

You can access the entire project in my Github:

https://github.com/nlankwei5/To-Do-List-Api

Feel free to comment, like and share. Also give advice on how to make this better.

I Pivoted from DevOps to Backend Software Engineering and Why It Was the Right Move for Me

Ebenezer Lamptey — Fri, 20 Jun 2025 13:35:35 +0000

Over the past few months, I’ve been exploring my path in software engineering. I originally set my sights on DevOps; the automation, the CI/CD pipelines, the cloud-native infrastructure... it all sounded exciting.

But I quickly realized something:
Entry-level DevOps roles are few and far between. Most job listings demand years of experience, deep system knowledge, and cloud certifications things that take time to build.

So I made a strategic shift.

I pivoted into backend development, specifically with Django and Django REST Framework. It wasn’t a complete departure, in fact, many of the skills overlap:

Writing efficient, testable code

Thinking in systems and logic

Managing environments and APIs

Designing clean, scalable backend architecture

More importantly, I found that backend engineering plays to one of my natural strengths:
I love logic. Solving problems, modeling real-world workflows in code, and making APIs that actually serve users that excites me.

Now I’m building a full-featured ToDo List API with authentication, permissions, validation, pagination, Docker support, and (soon) automated tests and deployment. I’ll even be sharing my journey soon.

Automate Your Amazon EC2 Instance Setup with LAMP Stack Using Bash

Ebenezer Lamptey — Tue, 24 Dec 2024 20:08:04 +0000

Introduction

Setting up an Amazon EC2 instance manually can be time-consuming, especially when configuring a LAMP stack (Linux, Apache, MySQL, PHP). This guide introduces a Bash script that simplifies the process, automating tasks such as AWS CLI installation, EC2 instance configuration, and LAMP stack setup. Whether you're new to AWS or a seasoned cloud engineer, this script can save you significant time and effort.

Prerequisites

Before running the script, ensure you have the following:

AWS account: Permissions to launch EC2 instances and configure security groups.
Key pair: Created in the AWS region you plan to use.
System requirements: A Debian-based Linux system with apt-get package manager.

Features

The script provides the following functionalities:

AWS CLI Check & Installation: Verifies if the AWS CLI is installed and installs it if missing.
Instance Launch: Automates EC2 instance creation with user-specified parameters.
Security Group Configuration: Sets up security rules to allow SSH access from your current IP.
LAMP Stack Installation: Installs and configures Apache, MySQL, and PHP on the instance.

Usage

Clone or download the script.
Make it executable:

   chmod +x setup_ec2.sh

Run the script:

   ./setup_ec2.sh

Follow the prompts to input:
- AMI Image ID
- Key Pair Name
- Instance Type (e.g., t2.micro)
- AWS Region
- Security Group ID
- Path to your private SSH key

Script Workflow

The script performs the following steps:

1. AWS CLI Check & Installation

If the AWS CLI is not found on your system, the script installs it using apt-get:

sudo apt-get update
sudo apt install -y awscli

2. AWS CLI Configuration

The script configures the AWS CLI using your access credentials:

aws configure

3. EC2 Instance Launch

Prompts you to enter required parameters, then launches an EC2 instance:

aws ec2 run-instances --image-id $image_id --key-name $key_name --instance-type $instance_type --region $region --query 'Instances[0].InstanceId' --output text

4. Security Group Configuration

Sets up SSH access by authorizing your current IP:

aws ec2 authorize-security-group-ingress --group-id $security_group --protocol tcp --port 22 --cidr $(curl -s https://checkip.amazonaws.com)/32 --region $region

5. Connect and Install LAMP Stack

Uses SSH to log in to the EC2 instance and install the LAMP stack:

ssh -i $PRIVATE_KEY_PATH ubuntu@$public_ip <<EOF
    sudo apt update && sudo apt -y upgrade
    sudo apt install -y apache2 mysql-server php libapache2-mod-php php-mysql
    sudo systemctl enable apache2
    sudo systemctl restart apache2
EOF

Example Output

An example of what to expect when running the script:

2024-11-09 12:00:00 - AWS CLI not found. Installing...
2024-11-09 12:01:00 - Configuring AWS CLI
2024-11-09 12:02:00 - EC2 instance i-1234567890abcdef0 launched successfully.
2024-11-09 12:03:00 - EC2 instance public IP: 18.217.123.456
2024-11-09 12:04:00 - Connecting to EC2 instance via SSH...
2024-11-09 12:05:00 - Setting up LAMP server
2024-11-09 12:10:00 - LAMP setup completed on EC2 instance i-1234567890abcdef0

Troubleshooting

AWS CLI Installation Fails: Ensure your system is Debian-based and supports apt-get.
Instance Launch Fails: Double-check your AWS credentials, region, and instance type.
SSH Connection Issues: Verify the private key path and ensure security group rules are configured correctly.

Conclusion

This Bash script streamlines the process of setting up an EC2 instance with a LAMP stack, automating repetitive tasks and reducing the potential for errors. By following the steps outlined in this guide, you can deploy a fully functional LAMP server in minutes. Try it out, and feel free to share feedback or suggestions for improvement!

see code here: Automate Your Amazon EC2 Instance Setup with LAMP Stack Using Bash

[Boost]

Ebenezer Lamptey — Thu, 05 Dec 2024 10:59:25 +0000

Comprehensive Bash System Monitoring Script: Technical Breakdown

Ebenezer Lamptey ・ Dec 4

#linux #bash #ubuntu

Comprehensive Bash System Monitoring Script: Technical Breakdown

Ebenezer Lamptey — Wed, 04 Dec 2024 16:45:14 +0000

In today's fast-paced IT environments, keeping track of system performance is crucial. This bash script provides an elegant, automated solution for monitoring critical system metrics and sending timely alerts when resources are under strain.

Understanding the Script's Architecture

The script is designed to monitor three primary system health indicators:

CPU Usage
Memory Consumption
Disk Space Utilization

Key Functionalities

Logging Mechanism

The script includes a robust logging function that timestamps every event. All system metrics and alerts are recorded in /var/log/sysmonitor.log, providing a comprehensive audit trail for system administrators.

logfile=/var/log/sysmonitor.log

log(){     
    local message=$1     
    echo "$message - $(date +%T)" >> $logfile 
}
# Logging function with timestamp
# Uses local variable for message
# Appends to log file with current time

Metric Collection

Each metric collection function leverages standard Linux command-line tools:

top for CPU usage
free **for memory consumption
**df for disk space utilization

CPU Usage Metrics

CPU_metrics(){    
    local cpu_usage=$(top -bn1 | grep "CPU(s)" | awk '{print $1 + $2 + $3}')
    echo "$cpu_usage"
    log "Cpu usage is $cpu_usage" 
}

# Uses `top` command to retrieve CPU usage
# Adds first three CPU percentage columns
# Logs the result

Memory Usage Metrics

Memory_metrics(){     
    local Mem_usage=$(free -m | awk '/Mem:/ {print ($3 / $2) * 100.00}')
    echo "$Mem_usage"
    log "Cpu usage is $Mem_usage" 
}
# Uses `free` command to calculate memory usage
# Calculates percentage of used memory
# Converts to percentage with decimal precision

Disk Usage Metrics

disk_usage_metrics(){     
    local disk_usage=$(df -h --total | grep ^total | awk '{print $5}' | sed 's/%//')
    echo "$disk_usage"
    log "Disk Usage is $disk_usage" 
}
# Uses `df` command to get total disk usage
# Removes percentage symbol for calculation

Metric Processing

dskusage=$(printf "%.0f" "$(disk_usage_metrics)")
memusage=$(printf "%.0f" "$(Memory_metrics)")
cpuUsage=$(printf "%.0f" "$(CPU_metrics)")
# Converts floating-point metrics to integers
# Uses printf to round to nearest whole number

Threshold-Based Alerting

The script defines critical thresholds for each metric:

Disk Usage: 75%
Memory Usage: 85%
CPU Usage: 90%

When any metric exceeds its predefined threshold, the script:

Logs the event in the system log
Sends an email alert to the specified address

CPU_threshold=90
Mem_threshold=85
Disk_threshold=75

if [ "$dskusage" -gt "$Disk_threshold" ] then
    echo "Disk limt exceeded!!!" 1>>$logfile
    mail -s "Disk Limit Alert" email@address.com <<< "Disk usage has exceeded Limit. Kindly review"
fi
# Checks if disk usage exceeds 75%
# Logs the event
# Sends email alert
# Similar logic for memory and CPU thresholds

Performance Automation

The script is scheduled using a crontab entry to run every 4 hours, ensuring continuous, hands-off system monitoring.

cron_job="0 */4 * * */workspace/Automated-System-Monitoring-/Monitor.sh 1>>$logfile"
(crontab -l | grep -v -F "$cron_job"; echo "$cron_job") | crontab -
# Schedules script to run every 4 hours
# Adds to crontab without duplicating existing entries

Implementation Tips

To use this script:

Replace email@address.com with your actual email
Ensure necessary permissions are set (chmod +x Monitor.sh)
Verify mail utility is configured on your system

Conclusion

Automated system monitoring is essential for maintaining infrastructure health. This bash script provides a lightweight, effective solution for tracking and alerting on critical system resources.

Sample Use Cases

DevOps teams monitoring server performance
Small to medium enterprise infrastructure management
Personal server and workstation health tracking

By proactively monitoring system metrics, you can prevent performance bottlenecks and potential system failures before they impact your operations. You can share ideas on improving this code in the comment section. Feel free to have discussions. you can accesss this code in my github : Automated Monitoring Script

Saving Time: Batch QR Code Generation with Bash

Ebenezer Lamptey — Mon, 25 Nov 2024 18:14:48 +0000

Ever found yourself manually creating QR codes one by one? As a choir marketing committee member, I was frustrated with online tools that either:

Limit free users to one QR code
Charge for bulk generation
Waste precious time

The Frustration

Our choir needed QR codes for multiple YouTube links to print on marketing t-shirts. Existing solutions? Painfully slow and expensive.

The Bash Solution

I wrote a simple script to automate QR code generation:

bash

# Check if input file is provided
if [ -z "$1" ]; then
    echo "Usage: $0 <input_file>"
    exit 1
fi

input_file="$1"

# Create a directory to store QR codes
mkdir -p qr_codes

# Generate QR codes for each URL in the input file
while IFS= read -r url; do
    filename="qr_codes/$(basename "$url").png"
    qrencode -o "$filename" "$url"
    echo "Generated QR code for $url"
done < "$input_file"

echo "QR codes saved in 'qr_codes' directory."

Key Benefits

Free
Fast
Customizable
No subscription needed

How It Works

Create a text file with URLs
Run the script

./qr_code.sh <text file>

Get QR codes in seconds

Pro Tips

Use with qrencode
Works for any links, not just YouTube
Easily scriptable and modifiable

You can see the code in my github
https://github.com/nlankwei5/Create-Qr-code/blob/main/qr_code.sh

Feel free to try it and give comments for more improvements
No more manual, repetitive work. 🚀

Building Your Own S3 Cloud Uploader CLI with Bash

Ebenezer Lamptey — Wed, 24 Jul 2024 15:32:06 +0000

Hey everyone! Today, I'm super excited to walk you through building your very own cloud uploader CLI using Bash. We'll cover everything from setting up your AWS S3 bucket to scripting the whole thing in Bash. I had an opportunity to also review a lot of peoples work and made mine a little bit different.

This project was completed and uploaded to this Github repository: Cloud Uploader Cli

Before we dive into the script, let’s talk a bit about Bash. Bash (Bourne Again Shell) is a Unix shell and command language. It’s widely available on various operating systems, especially on Linux. Shell scripting allows you to automate tasks by writing a series of commands in a script file. It’s super powerful for automating system administration tasks, managing file systems, and even developing simple CLI tools.

Getting Started with AWS S3

First things first, let's set up an S3 bucket on AWS. If you don't have an AWS account yet, go ahead and create one here. Once you're all set, follow these steps to create a bucket:

Log into the AWS Management Console: Head over to the S3 section.

Create a new bucket: Click on the "Create bucket" button. Give your bucket a unique name and choose a region that’s closest to you.

Bucket settings: Type the preferred name of the bucket making sure it is unique. You can pretty much go with the default settings for now. Just click through and create the bucket.

Getting Your AWS Access Keys

Now that we have our S3 bucket, we need to get our AWS access keys to allow our Bash script to interact with AWS services. Here’s how:

Navigate to IAM (Identity and Access Management): From the AWS Management Console, go to the IAM section.

Create a new user: Click on create user on you top right in orange background. Then after, select a username of your choice.

Set permissions: Select Attach policy directly and in the search box, search for s3. Select the policy "AmazonS3FullAccess".

After click on your user created on the Users page. select Security credentials.

Scroll down to find Access Keys then you create the access keys.
Download the .csv file containing your access key ID and secret access key. Keep these credentials secure. DON'T SHARE!!!

The Cloud Uploader Script

Alright, let’s get to the fun part – writing our Bash script!
Make sure you have the AWS CLI installed and configured on your system. You can install it on Linux terminal with the following commands:

sudo apt-get update

sudo apt-get install awscli

After installing AWS cli, you have to connect yout terminal to you aws account. You can do that by doing the following:

Run the AWS configure command

aws configure

Enter your credentials

AWS Access Key ID [None]: YOUR_ACCESS_KEY_ID
AWS Secret Access Key [None]: YOUR_SECRET_ACCESS_KEY
Default region name [None]: YOUR_DEFAULT_REGION
Default output format [None]: json

Replace YOUR_ACCESS_KEY_ID, YOUR_SECRET_ACCESS_KEY, and YOUR_DEFAULT_REGION with your actual AWS credentials and preferred region.

That’s it. We are now connected to AWS. WE can go on to writing our bash script.
Also install pv as well. (you will understand it's use soon)

sudo apt-get install pv

First create a bash script file that end in .sh eg: clouduploader.sh

Log Function: Logs events and errors to clouduploader.log for troubleshooting.

logfile="clouduploader.log"

log() {
    local message="$1"
    echo "$(date +'%Y-%m-%d %H:%M:%S') - $message" >> "$logfile"
}

AWS Configuration Check and Confirmation: Ensures AWS CLI is correctly configured and also has access to your S3 bucket.

# Read AWS credentials and configuration from environment variables or use defaults
AWS_ACCESS_KEY_ID="${AWS_ACCESS_KEY_ID}"
AWS_SECRET_ACCESS_KEY="${AWS_SECRET_ACCESS_KEY}"
AWS_DEFAULT_REGION="${AWS_DEFAULT_REGION}"
S3_BUCKET="${S3_BUCKET}"

# Function to check S3 configuration
check_s3_configuration() {
    echo "Checking S3 configuration..."
    if aws s3 ls "s3://$S3_BUCKET" &> /dev/null; then
        echo "S3 configuration is set correctly. The bucket $S3_BUCKET is accessible."
    else
        echo "Error: S3 configuration is incorrect or the bucket $S3_BUCKET is not accessible."
        exit 1
    fi
}

Argument check: Checks if the arguments passed are exactly 2 ie; the file path and destination path

if [ $# -ne 2 ]; then
    echo "Please provide exactly two parameters: the file path and the destination path."
    exit 1
fi

Assign 1st and 2nd arguments File path and destination path repectively and extract filename from file path

# Assign the first argument and second argument to FILEPATH and S3_DESTINATION respectively
FILEPATH="$1"
S3_DESTINATION="$2"

# Extract the filename from FILEPATH
file_name=$(basename "$FILEPATH")
echo "Filename: $file_name"

File Check: function to check if the file exists locally using -f

# Function to check if the file exists locally
file_check() {
    if [ -f "$FILEPATH" ]; then
        echo "$file_name exists."
    else
        echo "Error: $file_name does not exist."
        exit 1
    fi
}

File Upload: Uses AWS CLI to upload the file to the specified S3 destination with a progress bar. Note: "pv" already installed is a terminal-based (command-line based) tool in Linux that allows us for the monitoring of data being sent through pipe.

# Function to upload file to S3 with progress bar using pv
upload_to_s3() {
    local local_file="$1"
    local s3_destination="$2"

    # Upload the file to S3 using AWS CLI and capture output/error
    if pv "$local_file" | aws s3 cp - "$s3_destination"; then
        log "File upload successful: $local_file -> $s3_destination"
        echo "File upload successful: $local_file -> $s3_destination"
    else
        log "Error: Failed to upload file $local_file to $s3_destination"
        echo "Error: Failed to upload file $local_file to $s3_destination"
        exit 1
    fi
}

File Synchronization: Offers options to manage existing files in S3 (overwrite, skip, rename).

file_sync() {
    if aws s3 ls "$S3_DESTINATION$file_name"; then
        read -p "File already exists in S3. Overwrite, skip, or rename? [o/s/r]: " choice
        case $choice in
            o)
                upload_to_s3 "$FILEPATH" "$S3_DESTINATION"
                ;;
            s)
                echo "Skipping upload."
                ;;
            r)
                upload_to_s3 "$FILEPATH" "$S3_DESTINATION-renamed"
                ;;
            *)
                echo "Invalid choice. Skipping upload."
                ;;
        esac
    else
        upload_to_s3 "$FILEPATH" "$S3_DESTINATION"
    fi
}

# Perform file synchronization if needed
file_sync

Finally a function to generate a shareable link

presigned_url=$(aws s3 presign "$S3_DESTINATION$file_name" --expires-in 3600)
echo "Shareable link for the uploaded file: $presigned_url"

Running the Script

Save the script to to the created file, e.g., clouduploader.sh.
Make the script executable:

chmod +x clouduploader.sh

Run the script with the file path and S3 destination as arguments:

./clouduploader.sh /path/to/your/file s3://your-bucket-name/destination/

"/path/to/your/file" is your filepath and "s3://your-bucket-name/destination/" is your destination path

Advanced Features

Progress Bar: The script uses pv to show a progress bar during file upload.
Shareable Link: After a successful upload, the script generates a presigned URL for easy sharing.

Troubleshooting

Permissions: Ensure your IAM user has the necessary permissions to access and upload to the S3 bucket.
AWS CLI Configuration: Double-check your AWS CLI configuration and credentials.
Log File: Check clouduploader.log for detailed logs and error messages.

Wrapping Up!

You've now got your very own cloud uploader CLI that can upload files to your AWS S3 bucket. This is just the tip of the iceberg! There’s plenty more you can do to enhance this script – think about adding more features.By following this process you will be able to upload your files to S3 seamlessly through your Command Line.

Bash is incredibly powerful, and mastering it can really up your automation game. Whether it's for system administration, file management, or building custom tools, Bash scripting opens up a world of possibilities. For those keen to dive deeper, check out all bash resources online.

Happy scripting, and keep exploring!

Enjoy trying it out and I am open for any feedback and ideas.

New Journey

Ebenezer Lamptey — Wed, 26 Jun 2024 13:44:33 +0000

Hi everyone, I'm new here and I am a computer engineering graduate from Ghana Communications Technology University, Accra-Ghana in West Africa. I have always been curious abut the cloud and networking. The path has been a bit hazy for me for the past two years. I got completely confused. Finally a have a guide and a mentor to help out with my journey. I am restarting now hopefully I become a cloud engineer in the next six months. I'll be posting what i learn and share a few concerns and project I am undertaking. Your feedback is welcomed.