DEV Community: sudh33ra

The DevOps Prime Directive: Optimizing Your Environment for ADHD Success

sudh33ra — Wed, 16 Oct 2024 08:12:45 +0000

TL;DR

Tools that could help if you’re A devops with ADHD tendencies:
Obsidian
todo.txt (if you’re into CLI)
todoist (fast fix)
Notion ( A bit bloaty, but helps a lot)
Habitica (gamify)
Pomodoro (lot of apps out there that could help)
FlipD (Personally not a fan, but helps)

By nature, we’re lazy creatures that hate repetitive tasks, since they rarely give us the dopamine hit we need. That same aversion to monotony makes us the perfect candidates for automation — and that’s why DevOps feels like it was made for us!

In a world where DevOps engineers with ADHD navigate the complex systems of modern software development, success often feels as challenging as mastering Allomancy or commanding a fleet against the Formics. Like Vin discovering her powers or Ender strategizing in the Battle Room, these engineers must learn to harness their unique abilities while managing the chaos of their minds. Fear not, for this guide shall help you create a work environment as organized as Elend's library and as efficient as the ansible itself.

1. The Feruchemical Art of Brain Dumping

Just as Feruchemists store memories for later use, DevOps engineers with ADHD can benefit from a similar technique to manage distracting thoughts:

Create a digital repository for your fleeting ideas and tasks. This acts as your personal thought storage, always ready to capture those random inspirations.
Obsidian is an excellent tool for this purpose. Its linking capabilities allow you to create a web of interconnected thoughts, making it easy to retrieve and connect ideas later.
When a distracting thought arises, quickly jot it down in your chosen tool. This simple act of recording clears your mind, allowing you to refocus on the task at hand.
Set aside time later to review and process these stored thoughts. This practice helps prevent valuable ideas from slipping away while maintaining your current focus.
Over time, you'll develop a more organized mind, able to manage the constant influx of ideas that come with ADHD while staying productive in your DevOps tasks.

By mastering this technique, you'll enhance your ability to balance the creative aspects of ADHD with the focused demands of DevOps work.

2. The Battle Room of Focus

Create a workspace that minimizes distractions, much like a well-designed Battle Room:

Use noise-cancelling headphones to block out ambient chatter, allowing you to focus on your code with laser precision.
Set up a second monitor to expand your field of vision. If you're a MacBook user, your iPad can easily become a Sidecar, extending your desktop for improved productivity.
Employ ambient lighting that promotes focus and reduces eye strain, creating an environment where your ideas can flow freely.

3. Time Lord Techniques

Managing time with ADHD can feel like piloting the TARDIS blindfolded. Implement these strategies:

Use the Pomodoro Technique: Work in focused 25-minute bursts, like a Time Lord regeneration cycle. If you're on a MacBook, utilize the built-in Shortcuts app to create custom Pomodoro timers that automatically start your focus sessions and breaks.
Set up visual timers: A countdown display can help you stay aware of time passing, unlike the timey-wimey nature of a Time Vortex.

4. Replicate Like a Replicator

Just as the replicators in Star Trek can materialize objects on demand, automate your DevOps processes to materialize consistent environments and deployments:

Use Infrastructure as Code (IaC) tools like Terraform to create reproducible environments faster than you can say "Tea. Earl Grey. Hot."
Implement GitOps practices with tools like ArgoCD or Flux, ensuring your Kubernetes clusters are always in sync with your desired state, like a perfectly calibrated holodeck.
Set up chatbots for routine alerts and updates, like your own personal Computer from the Enterprise, always ready to provide status reports.

5. The Mindfulness Motherboard

Incorporate mindfulness practices into your routine:

Start your day with a brief meditation, focusing your mind like a Vulcan preparing for a mind-meld.
Use apps like Headspace or Calm for quick mental resets between tasks.

6. The Kanban Holocron

Visualize your workflow using Kanban boards:

Break down large tasks into smaller, manageable user stories.
Limit work in progress to avoid overloading your mental processors.
For a comprehensive solution, use Notion to create customizable Kanban boards that can link to other project resources.
If you prefer something simpler, Slack's built-in To-Do Lists feature can serve as a quick and easy Kanban system, always at your fingertips during team communications.

7. The Allies of Productivity

Remember, you're not alone in this battle against the Dark Side of distraction:

Pair program with a colleague to maintain focus and share knowledge.
Use collaborative tools like Slack or Microsoft Teams for quick communication, but set boundaries to avoid constant notifications.

By implementing these strategies, you'll create a work environment that supports both your DevOps responsibilities and your unique ADHD superpowers. Remember, in the words of Gandalf the Grey, "All we have to decide is what to do with the time that is given us." Now go forth and may your code be as strong as mithril and your deployments as swift as elven arrows!

Using Liquibase with Docker to automate DB changes

sudh33ra — Thu, 09 May 2024 09:25:01 +0000

Tame the chaos of database changes with Liquibase + docker.

TL;DR

git clone git@github.com:sudh33ra/liquibase_poc.git
cd liquibase_poc.git
mkdir temp && ./support_scripts/initLocalDB.sh --schema-name <schema_name>
#MAKE THE DB CHANGES IN LOCAL DB
./support_scripts/generateChangeLogRemote.sh --schema-name <schema_name> --change-tag <change_tag> --db-change-version <db_change_version>

In a world where software sorcery meets the mystical arts of database management, syncing different realms (environments) can be a real headache. But fear not, for Liquibase is here to sprinkle some magic on your database change management journey.

Liquibase, like a trusty wizard’s wand, brings several handy spells:

Version Controlled Changes: Think of it as tracking the evolution of spells. Liquibase keeps tabs on database tweaks, making it a breeze to reverse changes and pinpoint pesky database gremlins.

Environment Agnostic: Its spells don’t discriminate between realms, meaning changes written in Liquibase scrolls can seamlessly travel across different realms. It’s like having a universal translator for databases.

Automation: With a flick of a wand (or a few command lines), Liquibase automates the incantations of database updates, saving you from the perils of manual errors and speeding up the deployment process.

Now, onto crafting new changelogs with Liquibase, where even Docker gets a cameo:

Generating New Changelogs in Liquibase

Liquibase gives you two primary ways to create changelogs that track database changes:

Manual Changelog Creation: You write changelog files in SQL or other supported formats like XML, YAML, or JSON, allowing for fine-grained control over your database changes. This, while being the recommended way, is a bit of a hassle.

Changelog Generation by Comparing Databases: Here, Liquibase harnesses its powers to conjure changelogs by comparing the mystical essence of your development database, ripe with new enchantments, to that of a reference database, such as a staging environment.

Here we're gonna use an automated script to take the comparison approach

Prerequisites:

Docker installed.

Steps:

Configure Properties: Create a liquibase-local.properties file with connection details for your local database. (example file given in the repo)
Run Initiation Command: Execute this command, replacing variables:

mkdir temp && ./support_scripts/initLocalDB.sh --schema-name <schema_name>

Now your DB has the initial changes recorded in the liquibase tables. (you can see the script has generated sql files for the current db inside a temp folder in the repo directory)

Configure Properties: Create liquibase-remote.properties with connection details for your local (source) and staging (target) databases. (example file given in the repo)
Generate Changelog: Run the below command, replacing variables with your specific details:

./support_scripts/generateChangeLogRemote.sh --schema-name <schema_name> --change-tag <change_tag> --db-change-version <db_change_version>

Review and Refine: Carefully review the generated changelog to ensure it contains only the intended changes before applying it to other environments.

Additional Notes:

The db_change_version and change_tag parameters are crucial for organizing your database changes and ensuring they are applied in the correct order.
If you find that the change log generation process includes unintended changes, you can use the ./support_scripts/markLocalDB.sh command to mark your local database as up-to-date without actually applying changes.

Simplifying SVG Uploads to Amazon S3 with Flask and Docker

sudh33ra — Mon, 22 Jan 2024 06:55:05 +0000

Simplifying SVG Uploads to Amazon S3 with Flask and Docker
In the ever-expanding world of web development, efficiency and simplicity often go hand in hand. If you find yourself needing to upload SVG files to Amazon S3, this got you covered with a lightweight Flask application that makes the process a breeze.

Getting Started
To get started, clone the repository to your local machine. If you prefer using Docker, build the image and run the container. If not, a local Python environment will do the trick with a simple pip install command.

git clone https://github.com/sudh33ra/svg_uploader_to_s3.git
cd svg-uploader-to-s3
docker build -t svg-uploader .
docker run -p 5001:5001 svg-uploader

Or, for a local Python environment:

pip install boto3 Flask
python app.py

Now, the app is accessible at http://localhost:5001.

How to Use
Once the app is up and running, use tools like Postman or cURL to make a POST request to http://localhost:5001/upload. Include the necessary form fields:

svg_file_name: The desired name for your SVG file in S3.
svg_file_content: The content of your SVG file.
s3_bucket_name: The name of your S3 bucket.
Receive a JSON response indicating the success or failure of the upload.

Docker Configuration
If you need to set up AWS credentials, mount your AWS credentials and config directory using the following Docker command:

docker run -v /path/to/your/aws:/root/.aws -p 5001:5001 svg-uploader

Ensure your AWS credentials file (/path/to/your/aws/credentials) has the necessary permissions.

Conclusion
With this SVG Uploader to S3, you've got a reliable and straightforward solution for handling SVG file uploads to Amazon S3. Whether you prefer Docker or a local environment, the app is designed to simplify the process, allowing you to focus on what matters most—building incredible web experiences.

Feel free to explore the code, customize it to fit your needs, and happy coding!

Simplifying VPC Peering with Terraform

sudh33ra — Fri, 12 Jan 2024 05:42:47 +0000

Repo

TL;DR

clone the above
edit vars.tfvars
run the commands, you’re done

terraform init --reconfigure 
terraform plan -var-file=vars.tfvars -out tfplan 
terraform apply "tfplan"

Hey tech wizards! 🧙‍♂️ Ever wanted to connect two VPCs seamlessly? Look no further! This Terraform script is your go-to spell for creating a magical peering connection between two virtual realms.

The Spellbook

Players on the Stage

data "aws_caller_identity" "peer": Meet the peer. We're grabbing its identity details, setting the stage for our mystical connection.

resource "aws_vpc_peering_connection" "peer": The main act. We're weaving the connection, specifying the main VPC, the peer VPC, and other details. Tags act like name tags for our peering connection, keeping everything neatly labeled.

resource "aws_vpc_peering_connection_accepter" "peer": The gracious accepter on the other side. This player automatically nods to the peering connection. No need for manual approvals here!

resource "aws_route" "main_r" and resource "aws_route" "peer_r": Think of these as the traffic conductors. We're setting up routes in the route tables of both VPCs to guide the virtual traffic. It's like placing road signs for data.

The Dance Steps

**Requester's Moves: **We kick off the peering connection with the requester side. We're setting up the connection, specifying who we want to peer with, and tagging it as the "Requester" side.

Accepter's Groove: The accepter side gracefully accepts the connection, all automated. Tags say it's the "Accepter" side.

Routing Rhythms: We create routes in both VPCs to ensure data knows where to go. Think of it as programming the GPS for our virtual traffic.

The Magic Words

terraform init --reconfigure
terraform plan -var-file=vars.tfvars -out tfplan
terraform apply "tfplan"

Just chant these words in your terminal, and watch the magic unfold in your AWS console!

Important Notes

This script is your key to regional connections between VPCs. But remember, the magic words come with a note:

Note: After the spell is cast, make sure to enable DNS resolving on both sides for the full enchantment.

Happy peering,
SD

Secure and Scalable ECS with Terraform: A Quick Guide 2024

sudh33ra — Thu, 11 Jan 2024 11:58:56 +0000

Repo

TL;DR

clone the above
edit vars.tfvars
run the commands, you're done

terraform init --reconfigure 
terraform plan -var-file=vars.tfvars -out tfplan 
terraform apply "tfplan"

Hey tech enthusiasts! 🚀 Today, let's dive into the world of ECS (Elastic Container Service) with Terraform. If you're itching to get your hands dirty with some practical stuff, you're in the right place. This repository holds the keys to setting up an ECS cluster effortlessly. Grab a virtual coffee, and let's roll!

Getting Started
Alright, first things first. Open up the repo and take a stroll through the files. It's like an adventure, but in the tech realm. Follow this path:

backend.tf - Lay the foundation.
provider.tf - Set the stage with your AWS profile.
variables.tf/vars.tfvars - Tweak the settings based on your needs.
network.tf - Build the virtual networking.
security.tf - Lock it down. No unauthorized entry!
alb.tf - Introducing the star of the show - the Application Load Balancer (ALB).
ecs.tf - ECS steals the spotlight. Containers, ahoy!
auto_scaling.tf - Because who likes manual labor?
logs.tf - Keep an eye on what's happening.
outputs.tf - The grand finale. What's the verdict?

Let's Roll!
Feeling the adrenaline? Good! Now, let's hit the road:

Check Your AWS Configs: Ensure your AWS configurations are safe and sound. Nobody wants surprises, especially in tech.
Update Variables: Peek into vars.tfvars and customize it to dance to your tune.
The Magic Commands: Fire up your terminal and run these like a boss:

terraform init --reconfigure 
terraform plan -var-file=vars.tfvars -out tfplan 
terraform apply "tfplan"

Sit back, relax, maybe grab another sip of that coffee. Let Terraform weave its magic.
Voilà!: Once the smoke clears, you'll get a URL. That's your golden ticket to the application. Click and behold!

What's Next?

You've conquered this mountain; now it's time for the summit:
Link a Domain: Make it official. Attach a cool domain to that Load Balancer. Your ECS setup deserves to be seen by the world.

And there you have it, a casual stroll through ECS and Terraform. Now go, experiment, break things (not too much), and enjoy the journey!
Keep coding,
SD