DEV Community: Fave😌✨

GitPeek: Turning GitHub Data into Stories with Mux🔥🔥🎬

Fave😌✨ — Sun, 04 Jan 2026 22:31:35 +0000

This is a submission for the DEV's Worldwide Show and Tell Challenge Presented by Mux

What I Built🚀

I built GitPeek, a modern and expressive GitHub profile explorer that turns a developer’s GitHub data into a readable, story-like profile.

Instead of just listing numbers, GitPeek focuses on clarity, context, and personality, helping users quickly understand who a particular developer is, how they work, and what their GitHub activity says about them.

It fetches real-time data from the GitHub API and presents it in a clean, animated interface designed for both developers and non-technical viewers.

My Pitch Video✨

Demo🌍

🔗 Live Demo: GitPeek

📦 Source Code:

onlyfave / GitPeek

🧭 GitPeek — Read Your GitHub Story

GitPeek is a web application that goes beyond searching GitHub profiles.
It interprets public GitHub data to help you understand how a developer works, not just what they’ve built.

🔗 Live Demo: https://git-peek.netlify.app

📦 Source Code: https://github.com/your-username/gitpeek

📌 Why GitPeek Exists

GitHub profiles are powerful, but can be noisy.

Recruiters, collaborators, and even developers themselves often struggle to quickly understand:

What kind of developer is this?
Are they consistent or experimental?
Do they maintain projects or start many and abandon them?

GitPeek was built to answer those questions clearly and visually, using public GitHub data and a clean, focused interface.

✨ What GitPeek Does

GitPeek fetches public GitHub data and presents it in a way that is:

Easy to scan
Insight-focused
Human-readable

Instead of dumping raw data, GitPeek emphasizes patterns, behavior, and trends.

🚀 Core Features

🔍 Instant GitHub User…

View on GitHub

Key Features of GitPeek✨

1.GitPeek summarizes a developer’s GitHub identity, not just their repositories.

2.It translates GitHub data into plain-language insights.

3.GitPeek focuses on how a developer works, not just what they built.

4.It provides a visual, story-like profile.

5.GitPeek uses real-time GitHub API data.

6.It’s built for multiple audiences, not just developers.

7.No sign-in required.

You can analyze any public GitHub profile instantly.

How users can test it (no signup or login required):🎯

1. Open the link, enter any GitHub username in the search bar
2. View real-time profile and repository data
3. Observe UI responsiveness, animations, and error handling (you get an error when you type an invalid username)

No authentication or test credentials needed.🔒

The Story Behind It 📖

Problem
GitHub profiles are like digital fingerprints for developers. They're unique, revealing, and surprisingly personal. Yet, for all their value, they’re often misunderstood or overlooked.

Every profile is filled with signals: commit patterns, repository choices, favorite languages, project consistency, and long gaps or bursts of activity. To an experienced engineer, these patterns tell a story. To everyone else, they often look confusing.

Recruiters scroll.
Founders skim.
Beginners feel intimidated.

Important context gets lost.

Solution
I built GitPeek to answer a question I kept running into again and again:

“What does this developer’s GitHub actually say about them?”

Not just what tools they’ve used or how many repositories they have, but how they work:

Are they consistent or experimental?
Do they ship often?
Do they explore, abandon, return?

GitPeek doesn’t try to replace GitHub. Instead, it acts like a translator, taking raw GitHub data and reshaping it into something more readable, more human, and easier to understand at a glance.

The goal was clarity, not complexity.

By focusing on layout, hierarchy, and subtle motion, GitPeek helps viewers move from raw data to insight, turning commits and repositories into a coherent snapshot of a developer’s habits, growth, and mindset.

GitPeek exists because code tells a story.
Sometimes, it just needs help being read.

Technical Highlights✅

Frontend architecture: React (Vite) with a modular, component-based design
Theme support: Built-in light and dark modes that adapt seamlessly to user preferences while preserving contrast, readability, and visual clarity 🌗
API integration: Real-time data powered by the GitHub REST API
UI/UX execution: Tailwind CSS delivering a clean, consistent visual system
Motion design: Subtle Framer Motion animations used intentionally to guide user attention
Error Handling: Graceful handling of invalid usernames, empty states, and GitHub API rate limits
Responsiveness: Fully optimized for both desktop and mobile experiences

The core challenge was not fetching data, but deciding how to present it clearly and meaningfully.

Use of Mux (Additional Prize Category Participants Only)

Mux is used in GitPeek for multiple purposes:

Demo Video Hosting & Playback: The GitPeek pitch/demo video is uploaded as a Mux asset, processed for adaptive streaming, and embedded directly into the Dev.to post using the Mux playback URL. This ensures high-quality video delivery across devices without self-hosting or performance overhead.

Dynamic Cover Media Creation: Mux was used to generate the article’s cover video, adding a visually engaging, animated preview for readers.
GIF Generation from Video: The cover video produced with Mux was also converted into a GIF, which is embedded as an interactive visual element, enhancing storytelling and drawing attention to the article.

image.mux.com

Thank you for reviewing GitPeek✨.

❗ By submitting this project, I confirm that my video adheres to Mux's terms of service: https://www.mux.com/terms

🚀🧠Why Write 50 Scholarship Essays? I Let RunnerH Do It With One Prompt.🤯🔥🔥🔥🔥

Fave😌✨ — Sun, 06 Jul 2025 21:33:42 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

🧠 No More Essays. AI Hacked It.

Runner H Dev Challenge Submission by CloudFave

📌What I Built

Scholarships can be life-changing. But the essay workload? Overwhelming. This project shows how AI can level the playing field, saving time, energy, and mental stress while still keeping quality high.

If you've ever hunted for scholarships, you know the pain.

Hours of Googling. Dozens of open tabs. Rewriting the same essay 20 different ways.
By the end, you're exhausted... and you've only applied to two. 😩

I got tired of that life. So I built something better.

An AI-powered system that removes the hardest part of scholarship hunting: the essays. Runner H now finds eligible scholarships every week, organizes them, and drafts compelling essays for each—based on my personal statement.

✨ Highlights

⚡ 50 unique essays, 1 prompt

🎯 Hyper-targeted to each scholarship

📂 Organized and ready for submission

🧘 Zero burnout, all brains

Let me show you how it works 👇

✨Demo

🌀 Watch Runner H in action — the entire scholarship flow, live and unfiltered.🔥

AI bot finding scholarships, writing essays, and updating my sheet like a boss.

🚀🔥💻How I Used Runner H

I created a prompt that turns GPT into a weekly scholarship-hunting, essay-drafting, form-filling autopilot assistant. Here’s how the flow goes:

🧠 Prompt (Core Instruction)

✨ Prompt Template: Autonomous Scholarship Application Agent

(Built in Runner H format – step-by-step, human-in-the-loop, unstoppable.)

**You are my Autonomous Scholarship Assistant.**  
Your mission is to find, prepare, and organize weekly scholarship applications I’m eligible for, never proceeding without my explicit approval at each stage.

Here’s the workflow you must follow every week unless told otherwise:

🛠 1. Profile Setup (first run only):
- Ask for my email address (where you'll send drafts and summaries).
- Ask me to confirm or provide:
  - Nationality
  - Current level of study
  - Field of study
  - Gender (if relevant)
  - Academic or career interests
- Ask me to upload or paste my CV/personal statement.
- Confirm if I want to use this profile + CV for all future drafts.

🔍 2. Weekly Scholarship Search:
- Every Monday, search verified portals like OpportunityDesk, Scholars4Dev, and DAAD.
- Filter based on my profile to find eligible scholarships.
- Collect for each:
  - Name
  - Deadline
  - Eligibility
  - Essay requirement
  - Link to apply
- Present the top results (max 10 per week).
- Ask me to pick which ones you'd like to generate essays for.
- Do nothing else until I respond.

✍️ 3. Essay Drafting (for selected scholarships):
- For each approved one, generate a unique essay based on the prompt and my CV.
- Provide:
  - Scholarship name
  - Essay prompt
  - Word count
  - Drafted essay
  - Deadline
  - Link to apply
- Bundle all drafts into a clear weekly report or Google Doc.
- Ask if I’d like revisions or formatting help.

📬 4. Weekly Summary & Report:
- Create a Google Sheet tracker with:
  - Scholarship
  - Deadline
  - Status (Drafted / Pending / Skipped)
  - Notes column
- Send the tracker + all essays to my email.
- Ask: “All done for this week. Reply ‘Continue’ to start again next Monday or ‘Pause’ to take a break.”

🔁 5. Loop Rules:
- Wait for explicit "Continue" before restarting the next weekly search.
- If I reply "Pause", skip the next cycle.
- If I say "Reset", collect a new profile and CV.
- If I say "Archive", zip all past work and send the full archive.

🚫 Never apply to scholarships for me.
🚫 Never submit any forms.
✅ Always ask before moving forward.

Let me know when you're ready to begin.

🧠 **Built for busy students. Powered by AI. Focused on opportunity.**

💥Use Case & Impact

This wasn’t just AI flexing,it was about smart delegation. Runner H made me rethink productivity: why do it all yourself when you can strategize and supervise?

🏁 This is for every student who:

Struggles to keep up with scholarship deadlines

Feels overwhelmed writing essays from scratch

Doesn’t know where to start

This agent doesn’t just make life easier—it creates a repeatable, scalable system that can help students across Africa, Asia, LATAM, and anywhere funding is hard to come by.

It's a little bit of AI, a little bit of hustle, and a whole lot of peace of mind.

❤️Social Love

Posted it on X, LinkedIn, and my dev circles. Let’s help every student find their bag. 🎓💸

🍒X Post:
// Detect dark theme var iframe = document.getElementById('tweet-1941984422640697805-680'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1941984422640697805&theme=dark" }

🔗 Call to Action:

Runner H just hacked the most stressful part of student life.
Try this flow, remix it for your own use case, and tag me when you win that bag 🤑

Thanks for reading and thanks to Runner H for the dope prompt challenge! 💖

What Exactly Is Cloud Engineering?

Fave😌✨ — Wed, 04 Jun 2025 11:37:35 +0000

📢 Introduction

Have you ever been at a social gathering and introduced yourself as a cloud engineer, or answered the classic question, "What do you do?", only to be met with puzzled looks and the inevitable follow-up:

"What do cloud engineers actually do?"

You're not alone. Many people are curious about the cloud and what cloud engineers really do.

In simple terms, cloud computing is like renting a super-powerful computer over the internet. Instead of owning and maintaining physical hardware, businesses use resources provided by cloud providers like AWS, Azure, or Google Cloud.

But what does a cloud engineer do in this vast digital world? Let’s break it down step by step.

🌥️ What Is Cloud Computing?

Cloud computing is the on-demand delivery of IT resources over the internet with pay-as-you-go pricing.

Think of it like electricity or water, you don’t need to build a power plant or water system to use them. Similarly, cloud computing lets you access computing power, storage, and tools over the internet, without owning or managing the physical machines yourself.

✅ Six Benefits of Cloud Computing

1. No need to run and maintain data centers

Data centers require time, money, and manpower. Cloud computing removes that burden so you can focus more on your applications and customers.

2. Increased speed and agility

In traditional setups, it can take weeks to get new resources. With the cloud, you can spin up resources in minutes, perfect for experimenting and innovating.

3. Go global in minutes

You can instantly deploy your apps to servers around the world. This means customers everywhere can access your product with minimal latency.

4. Trade upfront expenses for variable costs

Instead of investing heavily in servers and infrastructure, you only pay for what you use, making cloud adoption more cost-efficient.

5. Stop guessing capacity

No more estimating hardware needs in advance. With cloud scalability, you can adjust resources based on real-time demand.

6. Benefit from massive economies of scale

Cloud providers serve millions of customers, allowing them to reduce costs and pass those savings on to you.

💻 Deploying to the Cloud

Cloud Computing Models

☁️ Infrastructure as a Service (IaaS)

Provides the fundamental building blocks like networking, virtual machines, and storage. You manage most of it yourself, giving you the highest control and flexibility.

🛠️ Platform as a Service (PaaS)

Removes the hassle of managing the underlying infrastructure. Developers can focus on building applications without worrying about maintenance, patching, or scaling.

📦 Software as a Service (SaaS)

A complete, ready-to-use software solution managed entirely by the provider. You just use the software, like Gmail, Zoom, or Google Docs, without thinking about how it runs behind the scenes.

✨ Responsibilities of a Cloud Engineer

Cloud engineers build, manage, and support cloud-based systems and services. Here's what they typically do:

1. Cloud Architecture

Design secure, scalable, and reliable cloud solutions tailored to business needs.

2. Deployment & Automation

Automate infrastructure with tools like Terraform, AWS CloudFormation, or Ansible.

3. Monitoring & Optimization

Use tools like CloudWatch, Datadog, or GCP Operations Suite to monitor system health and control costs.

4. Security & Compliance

Implement best practices to secure systems and ensure compliance with standards like GDPR, HIPAA, etc.

5. Team Collaboration

Work closely with developers, DevOps, and product teams to ensure seamless deployments and faster releases.

📚 Want to Learn More About Cloud Computing?

Here are some great resources to explore:

🌐 AWS Educate – Cloud 101 (Free)
☁️ Google Cloud Skills Boost – Cloud Digital Leader (Free)
📘 Microsoft Learn – Azure Fundamentals (Free)
💡 FreeCodeCamp – Full Cloud Computing Course (YouTube) (Free)
📗 "Cloud Computing: Concepts, Technology & Architecture" by Thomas Erl (Paid)
📚 Coursera – "Introduction to Cloud Computing" by IBM (Free with audit option)

🤝 Conclusion

Cloud engineers are the builders, guardians, and maintainers of the cloud. From designing infrastructure to monitoring performance, they ensure everything runs smoothly.

So, the next time someone asks,

“What do cloud engineers do?”,

you can say:

“We help the world run on the cloud — one scalable, secure, and seamless system at a time.”

🙏 Thanks for reading! If you found this helpful, feel free to connect or drop a comment on LinkedIn or Twitter.

IaC in Action: Deploying a Static Site with Pulumi, AWS & Cloudflare

Fave😌✨ — Sun, 06 Apr 2025 22:02:06 +0000

This is a submission for the Pulumi Deploy and Document Challenge: Fast Static Website Deployment

🚀What I Built

This project showcases how to deploy a static website from scratch using Pulumi with Python, Amazon S3 for website hosting, and Cloudflare for DNS and CDN.
The website, hosted at one-million.tech, was fully provisioned using infrastructure as code (IaC), enabling repeatable, automated, and version-controlled deployments.

🔗Live Demo Link

one-million.tech

📦Project Repo

🔗 https://github.com/onlyfave/Pulumi-deploy-static

Be sure to check out the README for a full step-by-step guide.

✍️ My Journey

I started this project with one primary goal in mind: to gain hands-on experience deploying infrastructure using Pulumi with Python, and to go beyond clicking buttons in the AWS console. I’d worked with static sites before, but this time, I wanted a clean, repeatable, automated way to manage the full lifecycle of a site, from code to cloud, using Infrastructure as Code (IaC).

🛠️ The Initial Setup

I chose Pulumi because it lets me write infrastructure in Python(my language of choice). I created a new Pulumi project and began scaffolding the resources needed for hosting a static site:

An S3 bucket with static site configuration
Public access policies (but with care, to keep things secure)
Uploading local site files to S3 using Pulumi’s FileAsset
DNS setup using Cloudflare to point my custom domain one-million.tech to the S3-hosted site

That was the plan. Simple on paper. But cloud deployments are never as smooth as you'd think at first glance 😅

I shared every challenge I encountered, from S3 bucket errors to DNS propagation pain, and how I resolved them. It’s packed with lessons, code snippets, and real dev struggles.
📖 How I Tamed the Cloud — Troubleshooting My S3, Cloudflare & Pulumi Static Site

🧠 Using Pulumi

Pulumi was the backbone of this project.

I used the Python SDK to define and provision an S3 bucket configured for static site hosting.
I added Cloudflare DNS configuration via Pulumi to route my custom domain (one-million.tech) to the S3 endpoint.
I uploaded static HTML files with correct types using Pulumi’s FileAsset.
I stored secrets and configs securely with pulumi config.

Why Pulumi?

IaC with a real language (Python💻)
No manual setup or clicking through AWS/Cloudflare dashboards
Version control + fast re-deployment
Seamless integration of multiple cloud providers

💡How I Tamed the Cloud: Troubleshooting My S3 + Cloudflare + Pulumi Static Site

Fave😌✨ — Fri, 04 Apr 2025 21:37:26 +0000

Troubleshooting My Static Website Deployment with S3, Cloudflare & Pulumi

Deploying a static website may seem simple at first glance, but behind the scenes lies a minefield of configuration details and cloud service quirks.

In this article, I'll walk through the key challenges I faced while deploying one-million.tech using Amazon S3, Cloudflare, and Pulumi and how I resolved each issue.

🛠️ The Goal

Build and deploy a static website to:

Host files on Amazon S3
Use Cloudflare for DNS + HTTPS
Automate infrastructure setup using Pulumi

🚧 Common Pitfalls I Encountered (And Fixed)

1. S3 Endpoint URL Error

Problem: While connecting my domain name to the S3 bucket, I received this error:

"Not a valid S3 website endpoint"

Cause: I used the full URL instead of just the region endpoint.

✅ Fix:
Use the correct format:

s3-website-us-east-1.amazonaws.com

Avoid including the full bucket path or http:// prefix.

2. DNS Record Already Exists

Problem:

"A record with the specified name already exists"

Cause: I attempted to create a new A record in Cloudflare while one already existed for @ (root domain).

✅ Fix:

Navigate to the DNS tab in Cloudflare.
Edit the existing record instead of creating a new one.

3. Pulumi Bucket Conflicts

Problem:
I wasn’t sure whether to delete an existing bucket used by Pulumi.

✅ Fix:

Double-checked that the bucket wasn’t associated with any critical data.
Deleted the unused pulumi-deploy-bucket and redeployed with a new Pulumi configuration.

4. 404 Not Found Error on My Domain

Problem:
Once the nginx page disappeared, the domain showed a 404 error.

Cause: S3 bucket wasn’t properly configured for static website hosting and index.html was missing.

✅ Fix:

Enabled "Static website hosting" in the bucket settings.
Uploaded index.html.
Specified index.html as the default root document.

5. Edits to index.html are Not Reflecting on the live site

Problem:
My changes to index.html were not showing up on the live site.

Cause: Cloudflare cached the old version of the site.

✅ Fix:

Uploaded updated index.html to S3.
Went to Cloudflare > Caching > Purge Everything.

8. Secrets Detected in GitHub Commits

Problem:
GitHub flagged my commits:

"Secrets detected in recent commits"

✅ Fix:

Added sensitive files like Pulumi.dev.yaml to .gitignore
Used git filter-branch to remove them from Git history:

git filter-branch --force --index-filter \
"git rm --cached --ignore-unmatch Pulumi.dev.yaml" --prune-empty --tag-name-filter cat -- --all
git push origin --force --all

🎉 Final Result

After working through these issues, I successfully deployed my static site:
🔗 https://one-million.tech

Everything is now cached, secure (HTTPS), and fast — thanks to Cloudflare and S3.

💡 Lessons Learned

Always double-check AWS bucket configuration for website hosting.
Cloudflare DNS takes time — patience is key.
Pulumi’s automation is powerful but unforgiving with secrets.
Cache is the usual suspect when updates don’t show.

Stay tuned for my GitHub repo and portfolio write-up!

If you’re planning to deploy your own static site with Pulumi, AWS, and Cloudflare, save this guide. It might just save you a weekend of debugging!

Written by: Fave — DevOps & Cloud Engineer

New to AWS Lambda? Here’s Everything You Need to Know to Get Started!🚀

Fave😌✨ — Tue, 01 Apr 2025 01:09:58 +0000

AWS Lambda: A Beginner's Guide to Serverless Computing

Introduction

Serverless computing is a cloud computing model where developers build and run applications without managing servers. The cloud provider handles infrastructure management, scaling, and billing, allowing developers to focus on coding.

One of the most popular serverless services is AWS Lambda, provided by Amazon Web Services (AWS).

AWS Lambda: An Overview

AWS Lambda is a serverless computing service that allows developers to run code without provisioning or managing servers. It is an ideal compute service for applications that need to scale up rapidly and scale down to zero when not in demand.

This guide explores AWS Lambda in detail, covering its architecture, key features, use cases, pricing, limitations, and how to deploy a simple function.

Key Features of AWS Lambda

1. Serverless Compute

Run code without managing servers.
No need to provision or manage infrastructure.

2. Automatic Scaling

Lambda automatically scales up or down based on the number of requests.
Handles thousands of requests per second dynamically.

3. Cost-Effective (Pay-as-You-Go Pricing)

You only pay for the compute time you consume (measured in milliseconds).
No upfront costs or idle server charges.

4. Multi-Language Support

AWS Lambda supports multiple programming languages, including:

Python
Java
Node.js
Ruby
Go
PowerShell

5. Reliability

Built on AWS infrastructure, ensuring high availability and reliability.

Use Cases for AWS Lambda

1. Data Processing

Process real-time data streams from services like Amazon Kinesis or DynamoDB Streams.

2. API Backends

Create and deploy serverless APIs using AWS Lambda with Amazon API Gateway.

3. Automation and Task Scheduling

Automated Backups

Schedule Lambda functions to perform automatic backups of data and applications.

Cron Jobs

Execute periodic tasks using AWS Lambda, eliminating the need for dedicated servers.

4. IoT Device Management

Manage IoT devices and configurations remotely.
Process real-time sensor data for monitoring and analysis.

5. Video Encoding

Process video files using Lambda functions for format conversion and optimization.

How to Get Started With AWS Lambda

Step 1: Create an AWS Account

If you don’t already have an AWS account, sign up for a free tier account at AWS Console.

Step 2: Access AWS Lambda

Log in to the AWS Management Console.
Search for Lambda in the AWS search bar.
Click Create function.

Step 3: Create a New Lambda Function

Choose a Method

Author from scratch → Create a function from scratch.
Use a blueprint → AWS provides pre-built templates.

Configure the Function

Name your function (e.g., myFirstLambda).
Choose a runtime (e.g., Python 3.9 or Node.js 18.x).
Set an execution role (AWS will create a default IAM role for you).
Click Create function.

Step 4: Write and Deploy Lambda Code

Write code directly in AWS Console or upload a ZIP file.

Here’s a simple Python example that returns "Hello, World!":

import json

def lambda_handler(event, context):
    return {
        'statusCode': 200,
        'body': json.dumps("Hello, World!")
    }

Step 5: Configure a Trigger (Optional)

Click Add Trigger.
Lambda functions can be triggered by changes in S3 buckets. To learn how to set this up, refer to my article on AWS S3 buckets for step-by-step instructions AWS S3

Step 6: Deploy and Test

Click Deploy.
Click Test → Choose Create new test event.
Run the test and check the output.

Challenges of AWS Lambda

1. Memory and CPU Limits

Maximum 3 GB memory with limited CPU resources.

2. Execution Time Limit

Functions can run for a maximum of 15 minutes.

3. Deployment Package Size

250 MB (uncompressed) limit for deployment packages.

4. Concurrent Execution Limits

AWS enforces limits on the number of concurrent executions.

5. Limited Logging and Monitoring

Debugging is challenging, especially for complex event-driven architectures.

6. Stateless Nature

AWS Lambda functions are stateless, making tracking across multiple executions difficult.

7. Debugging Difficulty

Traditional debugging methods do not work effectively in a serverless environment.

Next Steps

🔹 Try connecting AWS Lambda to Amazon API Gateway.
🔹 Use Lambda with Amazon S3 triggers.
🔹 Deploy Lambda using AWS SAM or Pulumi.

Conclusion

AWS Lambda revolutionizes serverless computing, allowing developers to build scalable, cost-effective applications without worrying about infrastructure. While it has some limitations, its flexibility, automatic scaling, and cost savings make it an excellent choice for modern cloud applications.

As serverless computing continues to evolve, AWS Lambda remains a leading solution for event-driven cloud applications.

✅ Found this guide helpful? Share it with your developer community! 🚀

Introduction to Ansible: A Beginner's Guide

Fave😌✨ — Sun, 16 Feb 2025 08:56:33 +0000

Introduction

Ansible is an open-source automation tool used for configuration management, application deployment, and task automation. It simplifies IT operations by automating repetitive tasks across multiple systems, ensuring consistency and reducing human errors.

Ansible was developed by Red Hat and has gained widespread adoption due to its agentless nature and easy-to-use YAML-based playbooks.

Perequisites

To learn Ansible effectively, you should have the following prerequisites:
1. Basic Linux Knowledge
2. Command Line and Terminal Usage
3. Networking Basics
4. YAML Syntax
5. Python Basics (Optional but Useful)
6. Basics of Configuration Management & Automation
7. Version Control (Git)
8. Cloud and Virtualization Concepts (Optional)

Why Use Ansible?

Ansible offers several benefits that make it a preferred choice for automation:

Agentless Architecture: Unlike other configuration management tools like Puppet or Chef, Ansible does not require agents on managed nodes. It connects using SSH or WinRM, reducing overhead and security risks.
Simple and Human-Readable: Ansible uses YAML for its configuration files, making it easy to understand and write. Even those with minimal coding experience can use it effectively.
Idempotency: Ansible ensures that tasks are only executed when necessary, preventing unintended changes. If a task is already applied, Ansible skips it, ensuring stability.
Scalability: It can manage thousands of systems efficiently with minimal resource overhead, making it ideal for large-scale IT environments.
Cross-Platform Support: Ansible supports Linux, macOS, Windows, and cloud environments like AWS, Azure, and Google Cloud. It can also manage network devices and containers.
Extensibility: With Ansible Galaxy, users can access a vast collection of pre-built roles and modules, enabling faster implementation of automation tasks.
Security and Compliance: Ansible allows enforcing security policies by automating compliance configurations and auditing system states.

How Ansible Works

Ansible operates by executing tasks on remote systems using a set of predefined instructions known as playbooks. Below is an overview of how Ansible works:

Inventory: A list of managed nodes (hosts) defined in an inventory file. The inventory file can be static or dynamic.
Modules: Small programs that perform tasks like installing packages, managing users, and configuring services. Ansible includes built-in modules and supports custom module development.
Playbooks: YAML files that define automation tasks and workflows. Playbooks can contain multiple plays and tasks, organizing automation steps efficiently.
Execution: Ansible runs the playbook against the inventory, connecting via SSH or WinRM to execute tasks.
Handlers and Variables: Ansible uses handlers to trigger actions when a change occurs and variables to make playbooks more dynamic.

Installing Ansible

To install Ansible on a Linux system, use the following command:

sudo apt update && sudo apt install ansible -y  # Debian/Ubuntu

For Red Hat-based systems:

sudo dnf install ansible -y  # Fedora/RHEL

To verify the installation:

ansible --version

For macOS:

brew install ansible

For Windows, Ansible can be used via the Windows Subsystem for Linux (WSL) or inside a Linux-based container.

Writing Your First Ansible Playbook

Below is a simple Ansible playbook that installs Nginx on a remote server:

---
- name: Install Nginx
  hosts: web_servers
  become: yes
  tasks:
    - name: Install Nginx
      apt:
        name: nginx
        state: present

Breaking Down the Playbook

name: A human-readable name for the play.
hosts: Specifies which inventory group to target (web_servers).
become: Grants administrator privileges for task execution.
tasks: Defines a list of tasks to be performed.
apt: Uses the Ansible package manager module to install Nginx.

To run this playbook:

ansible-playbook -i inventory.ini nginx-playbook.yml

Additional Ansible Commands

Here are some useful commands when working with Ansible:

Check connectivity to hosts:

  ansible all -m ping -i inventory.ini

Run a command on all hosts:

  ansible all -m shell -a "uptime" -i inventory.ini

Test a playbook without making changes (dry run):

  ansible-playbook -i inventory.ini nginx-playbook.yml --check

Ansible Best Practices

To effectively use Ansible, consider the following best practices:

Use Roles: Organize playbooks into reusable roles for better maintainability.
Use Variables and Templates: Avoid hardcoding values; use variables and Jinja2 templates.
Keep Playbooks DRY (Don't Repeat Yourself): Structure playbooks efficiently to avoid redundancy.
Secure Sensitive Data: Use Ansible Vault to encrypt sensitive data like passwords and API keys.

  ansible-vault encrypt secrets.yml

Test Playbooks: Validate playbooks in a staging environment before applying to production.

Resources

To learn more about Ansible, you can check out:

Official Documentation

Ansible Documentation – The best place to start, with official guides, module references, and best practices.

Books

Ansible for DevOps by Jeff Geerling – A hands-on guide to Ansible with real-world automation examples.
Ansible: Up and Running by Lorin Hochstein – Covers Ansible fundamentals and advanced topics.

Online Courses & Tutorials

Red Hat Ansible Training – Official training from Red Hat.
Udemy - Ansible for the Absolute Beginner – Great for beginners.
LinkedIn Learning - Learning Ansible – Covers Ansible basics and automation use cases.
YouTube - Jeff Geerling’s Ansible Tutorials – Free and practical Ansible tutorials.

Hands-on Labs & Practice

Katacoda Ansible Scenarios – Interactive labs for practicing Ansible commands and playbooks.
Play with Ansible – A browser-based Ansible playground.

Community & Forums

Ansible GitHub Repository – Source code and latest updates.
Ansible Community Slack – Connect with other learners and professionals.
Reddit - r/ansible – Discussions, use cases, and troubleshooting tips.

Conclusion

Ansible is a powerful tool that simplifies IT automation, making it easier to manage infrastructure at scale. With its agentless architecture, YAML-based playbooks, and vast module library, Ansible is an essential tool for DevOps engineers, system administrators, and cloud engineers.

By leveraging Ansible, organizations can achieve greater efficiency, security, and consistency in their IT environments!

FastAPI Book Management API with CI/CD: A Modern Developer's Guide Overview🔥

Fave😌✨ — Sun, 16 Feb 2025 08:14:29 +0000

FastAPI Book Management API

The FastAPI Book Management API is not just another RESTful API, it’s a high-performance, developer-friendly, and production-ready solution for managing books. Built with FastAPI, this project leverages modern web development practices to deliver a seamless experience for both developers and end-users. Whether you're a beginner exploring API development or an experienced developer looking to implement CI/CD, this project has something for everyone.

This article dives deep into the project setup, implementation, CI/CD pipeline, deployment strategies, and troubleshooting tips. By the end, you'll have a comprehensive understanding of how to build, deploy, and maintain a scalable API using tools and practices.

Why This Project Stands Out

This project isn’t just about managing books—it’s about building a modern API that adheres to best practices. Here’s what makes it special:

FastAPI Framework: Lightning-fast performance with asynchronous support.
CRUD Operations: Full support for creating, reading, updating, and deleting books.
Input Validation: Robust validation using Pydantic schemas to ensure data integrity.
CORS Middleware: Secure cross-origin resource sharing for frontend integration.
Automated Documentation: Interactive API documentation powered by OpenAPI and Swagger UI.
CI/CD Pipeline: Automated testing and deployment using GitHub Actions.
Dockerization: Containerized deployment for consistency across environments.
Nginx Reverse Proxy: Enhanced performance and security for production deployments.

Features

1. FastAPI Framework

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.7+ based on standard Python type hints. It’s designed to be easy to use, highly performant, and production-ready. With built-in support for programming, it’s perfect for handling high traffic and complex workflows.

2. CRUD Operations

The API supports all basic CRUD operations:

Create: Add new books to the collection.
Read: Retrieve a single book or a list of all books.
Update: Modify existing book details.
Delete: Remove books from the collection.

3. Input Validation

Using Pydantic, the API ensures that all incoming data is validated before processing. This prevents invalid data from entering the system and reduces the risk of errors.

4. CORS Middleware

Cross-Origin Resource Sharing (CORS) is enabled to allow frontend applications (e.g., React, Angular) to interact with the API seamlessly.

5. Automated Documentation

FastAPI automatically generates interactive API documentation using OpenAPI and Swagger UI. This makes it easy for developers to explore and test the API endpoints.

6. CI/CD Pipeline

The project includes a GitHub Actions workflow for continuous integration and deployment. This ensures that every code change is tested and deployed automatically, reducing the risk of bugs in production.

7. Dockerization

The API is containerized using Docker, making it easy to deploy and run in any environment. Docker ensures consistency across development, testing, and production environments.

8. Nginx Reverse Proxy

For production deployments, Nginx is used as a reverse proxy to improve performance, handle load balancing, and enhance security.

Project Setup

1. Clone the Repository

Start by cloning the repository to your local machine:

git clone https://github.com/onlyfave/fastapi-book-project.git
cd fastapi-book-project

2. Install Dependencies

Ensure you have Python installed, then install the required dependencies:

pip install -r requirements.txt

3. Run the FastAPI Server

Start the FastAPI server using Uvicorn:

uvicorn main:app --host 0.0.0.0 --port 8000 --reload

Access the API at: http://127.0.0.1:8000

Explore the interactive documentation at: http://127.0.0.1:8000/docs

API Endpoints

1. Health Check

Endpoint: GET /healthcheck

Response:

{
  "status": "active"
}

2. Create a Book

Endpoint: POST /api/v1/books/

Request Body:

{
  "id": 1,
  "title": "The Hobbit",
  "author": "J.R.R. Tolkien",
  "publication_year": 1937,
  "genre": "SCI_FI"
}

Response:

{
  "id": 1,
  "title": "The Hobbit",
  "author": "J.R.R. Tolkien",
  "publication_year": 1937,
  "genre": "SCI_FI"
}

3. Get All Books

Endpoint: GET /api/v1/books/

Response: List of books

4. Get a Book by ID

Endpoint: GET /api/v1/books/{book_id}

5. Update a Book

Endpoint: PUT /api/v1/books/{book_id}

6. Delete a Book

Endpoint: DELETE /api/v1/books/{book_id}

CI/CD Pipeline Setup

GitHub Actions Workflow

The CI/CD pipeline is powered by GitHub Actions. Here’s how it works:

Trigger: The pipeline runs on every push or pull request.
Build: The code is checked out, Python is set up, and dependencies are installed.
Test: Automated tests are run using pytest.
Deploy: If the build and tests pass, the code is deployed to the server.

name: CI/CD Pipeline

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.10'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt

      - name: Run Tests
        run: pytest

  deploy:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to server
        run: echo "Deploying..."  # Replace with actual deployment steps

Deployment

Using Docker

Create a Dockerfile:

FROM python:3.10-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Build and Run the Docker Container:

docker build -t fastapi-book-api .
docker run -d -p 8000:8000 fastapi-book-api

Verify the Deployment:

curl http://localhost:8000/healthcheck

Debugging & Troubleshooting

1. Check Running Containers

docker ps

2. View Application Logs

docker logs <container_id>

3. Restart Deployment

docker stop <container_id>
docker start <container_id>

4. Check CI/CD Pipeline Logs

Go to GitHub → Actions tab and check if the build or deployment failed.

Future Enhancements

This project is just the beginning. Here are some ideas for future improvements:

Authentication: Add user authentication using OAuth2 or JWT.
Database Integration: Use a database like PostgreSQL or MongoDB for persistent storage.
Book Recommendations: Implement a recommendation engine based on user preferences.
Rate Limiting: Protect the API from abuse by implementing rate limiting.
Monitoring: Add monitoring and logging for better observability.

Conclusion

The FastAPI Book Management API is a powerful, scalable, and modern solution for managing books. With its robust features, automated CI/CD pipeline, and containerized deployment, it’s ready for production use. Whether you’re building a personal library or a large-scale book management system, this project provides a solid foundation to build upon.

So, what are you waiting for? Dive into the code, experiment with the API, and take your development skills to the next level.
Happy Coding! 🚀

From Code to Cloud: Building and Deploying a Smart Number Classification API with FastAPI

Fave😌✨ — Thu, 06 Feb 2025 00:12:37 +0000

Number Classification API

Overview

The Number Classification API is a FastAPI-powered web service that classifies numbers based on their mathematical properties and provides a fun fact. It determines whether a number is prime, perfect, Armstrong, even, or odd and fetches an interesting fact from an external API.

Features

Classifies numbers based on mathematical properties.
Fetches fun facts using the Numbers API.
Provides a structured JSON response.
Handles errors gracefully and ensures valid integer input.
Publicly accessible and deployed on Google Cloud Compute Engine (GCE).

API Endpoint

Classify a Number

GET /api/classify-number?number=<integer>

Request Parameters

Parameter	Type	Required	Description
`number`	int	Yes	The number to classify

Successful Response (200 OK)

{
    "number": 371,
    "is_prime": false,
    "is_perfect": false,
    "properties": ["armstrong", "odd"],
    "digit_sum": 11,
    "fun_fact": "371 is an Armstrong number because 3^3 + 7^3 + 1^3 = 371"
}

Error Response (400 Bad Request)

{
    "number": "abc",
    "error": true,
    "message": "Invalid input. Please enter an integer."
}

Deployment Details

Framework: FastAPI (Python)
Hosting Platform: Google Cloud Compute Engine (GCE)
Port: 8000
CORS Handling: Enabled to allow cross-origin requests

Installation & Setup

Prerequisites

Python 3.8+
FastAPI & Uvicorn
Virtual Environment (optional but recommended)

Steps to Run Locally

# Clone the repository
git clone https://github.com/onlyfave/Number-classification-api.git
cd Number-classification-api

# Create a virtual environment
python3 -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Run the FastAPI server
uvicorn main:app --host 0.0.0.0 --port 8000 --reload

Deployment on Google Cloud Compute Engine (GCE)

Create a VM Instance on GCE.

Install dependencies:

   sudo apt update && sudo apt install python3-pip
   pip install fastapi uvicorn

Run the API in the background:

   nohup uvicorn main:app --host 0.0.0.0 --port 8000 &

Allow external traffic on port 8000:

   gcloud compute firewall-rules create allow-fastapi \
       --allow tcp:8000 \
       --target-tags=http-server \
       --description="Allow FastAPI traffic"

or do it manually in the VPC Firewall settings

Verify API is accessible:

   curl http://35.209.49.217:8000/

Project Structure

Number-classification-api/
│── main.py               # FastAPI application
│── requirements.txt      # Project dependencies
│── README.md             # Documentation (this file)
└── .gitignore            # Git ignore file

Screenshots

Python file(main.py)

Example API Response

API Running Successfully

Pushed to GitHub

Technologies Used

Testing the API

You can test the API using cURL, Postman, or a web browser:

curl "http://35.209.49.217:8000/api/classify-number?number=42"

Author

Favour Onyeneke
GitHub link: onlyfave

Conclusion

The Number Classification API is a lightweight and efficient API that provides mathematical insights and fun facts about numbers. Future improvements may include support for additional number properties and performance optimizations.🔥

Best resource to understand Prometheus and what it entails🔥

Fave😌✨ — Tue, 04 Feb 2025 13:33:44 +0000

Prometheus Architecture: Understanding the Workflow 🚀

Favour Lawrence ・ Feb 3

#devops #monitoring #programming #beginners

How I Configured NGINX on a Fresh Ubuntu Server: My Experience

Fave😌✨ — Fri, 31 Jan 2025 17:54:01 +0000

Configuring NGINX on a Fresh Ubuntu Server: My Experience

Setting up NGINX on a fresh Ubuntu server is a fundamental task for any DevOps engineer. Recently, I had to configure NGINX on a brand-new Ubuntu instance and serve a custom HTML page as the default page. While the process is straightforward, I encountered some challenges and learned a few valuable lessons along the way. In this blog post, I’ll share my experience, step-by-step setup, and troubleshooting tips.

🚀 Setting Up the Environment

To start, I spun up a new Ubuntu server instance on Google Cloud Platform (GCP) Compute Engine. After provisioning the server, I connected to it via Google Cloud SSH:
If you're using any other cloud platform, you can SSH into it using the IP address:

ssh ubuntu@your-server-ip

🚀 Installing NGINX

NGINX is not installed by default on Ubuntu, so the first step I did was to update the package list and install it:

sudo apt update
sudo apt install nginx -y

Once installed, I checked the status to ensure it was running:

sudo systemctl status nginx

It wasn’t running, so I started and enabled it to run on boot:

sudo systemctl start nginx
sudo systemctl enable nginx

🚀 Creating a Custom HTML Page ✨

NGINX serves files from /var/www/html. So to customize the default page, I created an index.html file inside this directory:

sudo vim /var/www/html/index.html

NB: We have two major text editors which we use on the terminal; Vim and Nano (I just prefer using Vim).

I added a simple HTML page:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Welcome To My HTML Page!</title>
    <style></style>
</head>
<body>
    <div style="font-size: 8rem;">Welcome To DevOps Stage 0 - Fave💕✨</div>
</body>
</html>

After saving the file, I needed to restart NGINX for the changes to take effect:

sudo systemctl restart nginx

🚀 Configuring NGINX to Serve the Custom Page

In some cases, the default NGINX configuration might not serve the custom HTML page correctly. So I verified that the default server block in /etc/nginx/sites-available/default was set up properly:

sudo nano /etc/nginx/sites-available/default

I ensured the configuration looked like this in the default file:

server {
    listen 80 default_server;
    listen [::]:80 default_server;

    root /var/www/html;
    index index.html;
    server_name _;

    location / {
        try_files $uri $uri/ =404;
    }
}

After saving the changes, I tested the configuration:

sudo nginx -t

Everything was fine, so I reloaded NGINX:

sudo systemctl reload nginx

🚀 Testing the Setup

To verify that everything worked correctly, I accessed the server’s public IP address in a web browser:

http://34.59.6.191

I was greeted with my custom HTML page!! 😌💅

🚀 Challenges I Faced

While the process might seem smooth, I encountered some challenges and I had to troubleshoot:

NGINX not starting: Running sudo nginx -t helped identify if I missed any steps or configurations.
Page not updating: Clearing the browser cache or restarting NGINX usually fixed this.
Firewall blocking requests: I had to edit the firewall rule on my instance to only serve port 80. Ensuring the firewall allowed HTTP traffic solved the issue.

🚀 References:

🚀 Conclusion

Configuring NGINX on a fresh Ubuntu server to serve a custom HTML page was a great learning experience. While the setup process was mostly smooth, troubleshooting minor issues reinforced my understanding of how NGINX handles requests and configurations. If you're setting up a web server for the first time, following these steps should help you get started quickly.

Thanks 😌🔥

Building a Scalable Real-Time NBA Stats Pipeline With AWS: Unlocking Seamless Data Integration

Fave😌✨ — Fri, 31 Jan 2025 12:42:00 +0000

NBA Statistics Pipeline🏀

🚀 Introduction

This project is an NBA Statistics Pipeline that fetches NBA team statistics from the SportsData API and stores them in AWS DynamoDB. The project also implements structured logging using AWS CloudWatch, enabling efficient monitoring and debugging.

This project was built to demonstrate my proficiency in AWS services, Python, API integrations, and Infrastructure as Code (IaC).

🛠 Tech Stack

Python (Data processing, API requests, logging)
AWS DynamoDB (NoSQL database for storing NBA stats)
AWS CloudWatch (Logging & monitoring)
Boto3 (AWS SDK for Python)
Docker (Containerization)
EC2 Instance (Compute environment for development)

🎯 Features

Fetches real-time NBA statistics from the SportsData API
Stores team stats in AWS DynamoDB
Structured logging with AWS CloudWatch
Error handling and logging with JSON structured logs
Uses environment variables for sensitive credentials
Implements batch writing for efficiency

📸 Snapshots

API Response Sample

DynamoDB Table Data

CloudWatch Logs (Structured logs for monitoring)

Terminal Output (Successful execution of the pipeline)

🏗 Project Architecture

└── nba-stats-pipeline
    ├── src
    │  ├── __init__.py
    │  ├── nba_stats.py
    │  ├── lambdafunction.py
    ├── requirements.txt      # Dependencies
    │   ├── .env              # Environment variables
    │   ├── Dockerfile        # Containerization setup (if applicable)
    ├── README.md             # Project documentation

🚀 Step-by-Step Guide to Building the NBA Stats Pipeline

4️⃣ Launch EC2 Instance and SSH Into It

ssh -i "nba-stats-pipeline.pem" ubuntu@ec2-18-212-173-76.compute-1.amazonaws.com

1️⃣ Clone the Repository

git clone https://github.com/onlyfave/nba-stats-pipeline.git
cd nba-stats-pipeline

1️⃣ Install Python3

Python3 is required to run the project.

sudo apt update
sudo apt install python3

1️⃣ Install Pip

On most systems, pip comes pre-installed with Python3. To verify, run:

pip3 --version

If you don't have pip installed, use the following command:

sudo apt install python3-pip

2️⃣ Install Dependencies

pip install -r requirements.txt

3️⃣ Set Up Environment Variables

Create a .env file with the following content:

SPORTDATA_API_KEY=your_api_key
DYNAMODB_TABLE_NAME=nba-player-stats
AWS_ACCESS_KEY_ID=your_access_key
AWS_SECRET_ACCESS_KEY=your_secret_key
AWS_REGION=us-east-1

4️⃣ CD Into the Folder Containing the Pipeline

cd src

4️⃣ Run the Pipeline

python3 nba_stats.py

📊 Sample Data Format

[
  {
    "TeamID": 1,
    "TeamName": "Los Angeles Lakers",
    "Wins": 25,
    "Losses": 15,
    "PointsPerGameFor": 112.5,
    "PointsPerGameAgainst": 108.3
  }
]

🏗 Deployment (Optional: Dockerized Version)

To run this project inside a Docker container:

docker build -t nba-stats-pipeline .
docker run --env-file .env nba-stats-pipeline

🔥 Key Takeaways

AWS Expertise: Used DynamoDB & CloudWatch for data storage & monitoring
DevOps Skills: Managed credentials, logging, and error handling efficiently
Cloud-Native Thinking: Designed a cloud-based ETL pipeline

📌 Next Steps

Implement Lambda Functions for automated execution
Deploy using AWS ECS or Kubernetes
Integrate with Grafana for real-time data visualization

📢 Connect With Me

🚀 LinkedIn | 🐦 Twitter/X