The Journey to Certification

Why I Took the Exam

Now, you might be wondering, "Rishab, you’re a developer advocate at Twilio, why focus on cloud security?" Well, here’s the deal. I’ve always envisioned myself working in some aspect of cloud security in the future. Not that I’m planning on leaving developer relations anytime soon, but when the time comes to transition to a more security-focused role, I believe this will be the smoothest route for me. Why? Because I’ve got five years of cloud engineering and DevOps experience, and adding security to that mix seems like the most natural progression.

This was my chance to deepen my knowledge of Google Cloud security, and I'm glad I took it. The GCP Cloud Security certification aligns with my long-term goals of gaining more specialized cloud security skills.

The Tight Timeline

Now, here’s where it gets interesting. I only had 8 days to prepare for the exam, which is a pretty short timeline for something as comprehensive as this. Why the rush? Well, as a Google Developer Expert (GDE), I had a certification voucher that would expire by April 1st. So, I had no choice but to prepare quickly, but I was confident that my hands-on experience would help me move through the material faster.

I started prepping on March 22nd, and the exam was scheduled for March 30th, just a week to go through the material and practice.

Exam Overview

Before jumping into study materials, let’s talk a bit about what the exam actually covers:

The Cloud Security Engineer exam assesses your ability to:

• Configure access and secure communication within Google Cloud

• Establish boundary protection and manage data protection

• Support compliance requirements and manage operations

You can find all this information in the official exam guide, and I highly recommend reading it before starting your prep. It provides a solid understanding of the services you’ll need to master, plus the weightage of each domain in the exam.

For this exam, Google recommends that you have 3+ years of industry experience, with at least one year of hands-on experience designing and managing solutions in Google Cloud. While I didn’t have years of cloud security experience specifically, my background in cloud engineering and DevOps helped a lot. I focused on practicing hands-on labs and building projects with a security mindset, which worked well for me.

Exam Details

• Duration: 2 hours

• Questions: 50-60 multiple-choice questions

• Cost: $200 (I used my GDE voucher)

• Format: Multiple-choice questions covering various topics in cloud security.

Study Resources & Strategy

Let’s get into the nitty-gritty of the study materials I used.

Hands-on Projects & Labs

As you know, I’m a big believer in hands-on learning, it’s the only way to truly retain skills. That’s why I prioritized projects and labs over just reading books or watching videos.

One of the projects I worked on was updating my home lab. I have a spare Linux server running Docker and Kubernetes in my home network. I set up a secure tunnel system using Tailscale to connect my server at home to my GCP Ubuntu server, ensuring secure communication between both. This project involved configuring VPCs, firewall rules, and networking, all of which were essential for the exam.

Another project was a URL shortener hosted on Google Cloud using Cloud Run. This project helped me practice security principles like:

• Service accounts for secure access between GCP resources

• Cloud Armor and Cloud CDN for security and performance

• Cloud Logging and Monitoring for auditing and visibility

These hands-on projects reinforced my understanding of Google Cloud’s security features and were invaluable in preparing for the exam.

Books and Online Courses

• I used the Google Cloud Certified Professional Cloud Security Engineer Exam Guide by Ankush Chadri and Prashant Kulkarni (available on O'Reilly). I didn’t complete the entire book but referred to it for specific topics like Data Loss Prevention (DLP) and Cloud Encryption.

• I also used Google Cloud Skills Boost Security Engineer path, which offers interactive labs and courses. This is a great resource if you want a more structured path for your learning.

• Additionally, I referenced courses from Cloud Academy, which I accessed through my AWS Community Builder membership. This course had hands-on labs and was really helpful for reinforcing key concepts.

Practice Exams

I always recommend taking practice exams before the real deal. I used Whizlabs practice exams to test myself on the specific domains. The exams on Whizlabs are domain-based, so you can focus on specific areas that need more attention. I completed almost all of them, and this helped me identify areas where I was weaker, allowing me to focus my limited study time more effectively.

Exam Experience

When exam day came, I felt ready. The exam took me about 1 hour and 5 minutes to complete, leaving me with time to review my answers. Google Cloud certifications don’t provide a score breakdown, but I passed, and the Credly badge was issued the very next day!

Here are some key topics to focus on for the exam based on my experience:

Key Focus Areas

1. Network Security: VPCs, subnets, firewalls, load balancing, and private Google access. Understanding how to secure networks and control traffic flow is crucial.

2. Data Security: Encryption techniques, protecting data at rest and in transit, Customer Managed Encryption Keys (CMEK), and Data Loss Prevention (DLP).

3. Detection and Response: Learn about Security Command Center, Cloud Logging, and Cloud Monitoring. These tools help with visibility and auditing your cloud resources.

4. Security Best Practices: Understand binary authorization (ensuring only trusted containers are deployed) and compliance assessments.

I have also made my notes publicly available for you all to review:

Final Thoughts

Passing the Google Cloud Professional Cloud Security Engineer exam was a challenging but rewarding experience. The key to my success was a balanced approach that combined hands-on projects, lab practice, and focused study resources. Even with a tight timeline, the experience and skills I gained during the preparation process made it all worth it.

If you're preparing for this exam, I wish you the best of luck! Stay focused, dive into hands-on labs, and remember that the best way to solidify your knowledge is through practical experience.

As for me, I’ve already got my sights set on the GCP DevOps Professional certification next, and I’ll be sharing my journey with that soon!

I am thrilled to share that I recently passed the new Google Cloud Generative AI Leader Exam! This foundational certification is a great way to validate your knowledge of GenAI concepts and Google Cloud's offerings, even if you don't have extensive technical experience.

For my preparation, I focused on the official learning paths and leveraged my existing hands-on experience. I wasn't surprised that the exam content very closely matched the objectives laid out in the study guide, which made the process very straightforward.

Here is my study guide based on the resources I used and my experience sitting for the exam.

Exam Overview

The Generative AI Leader certification is a foundational exam designed to assess your knowledge across four key areas.

• Format: Multiple-choice questions (50-60 total)

• Time Limit: 90 minutes

• Cost: $99 USD

• Delivery: Online (proctored) or in-person at a test center

• Validity: 3 years

Skills Measured in the Exam

The official exam guide provides a clear breakdown of the weightage for each section. I found that the actual exam reflected these percentages very well.

Resources I Used

I relied completely on two main educational resources and my practical experience to prepare for this certification.

1. Cloud Skills Boost Learning Paths

• Generative AI Leader Path: This path has five courses and is specifically aligned with the certification.

• Introduction to Generative AI Path: If you are new to the field, I highly recommend going through this path as well. I particularly enjoyed the modules on Responsible AI, which are crucial for understanding Google Cloud's offerings.

2. Hands-on Experience

While this is a foundational exam, having practical experience was a huge advantage. My experience working with the Gemini API and Vertex AI and its offerings, such as implementing RAG (Retrieval-Augmented Generation) with BigQuery, helped me understand the concepts not just theoretically but practically.

3. Personal Notes

I also took extensive personal notes and created mind maps to help internalize the details. I've cleaned up and shared my personal notes publicly for anyone preparing:

The Experience

I found the online proctoring process straightforward, though it does require you to ensure your environment is clean and free of notes. I finished the exam in about 65 minutes, well within the 90-minute limit.

You get an immediate pass/fail result, but the official confirmation and your Credly badge usually take about 24 hours to arrive via email.

Good luck to anyone planning to take the Google Cloud Generative AI Leader exam! Let me know in the comments if you have any questions.

I tried staying back after work to study AWS, but most days I was drained. After troubleshooting tickets for 8 hours, my brain was fried. So I made a small shift — I started coming in early. One hour before my shift started, I’d grab a coffee and study.

That one change made all the difference.

No one told me to do it. There was no applause. But it gave me a sense of control. I wasn’t just reacting to life anymore — I was preparing for what I wanted next.

“You have power over your mind – not outside events. Realize this, and you will find strength.”
— Marcus Aurelius

Why Bother?

If you already work full-time, it’s easy to justify skipping the extra effort.

“I’m tired.”
“There’s no time.”
“I’ll start next week.”

I told myself the same things.

But the truth is, you don’t need motivation. You need a reason. Mine was simple: I wanted to do better for my family — and my bank account was a constant reminder of that.

“First say to yourself what you would be; and then do what you have to do.”
— Epictetus

Study to Excel, Not Just to Escape

When I got promoted to a Cloud Engineer role, I didn’t stop studying.

But the focus shifted. I wasn’t studying to get out — I was studying to get better. I spent time learning architecture patterns, reading about what other companies were building, and figuring out how to apply those ideas in our own environment.

This wasn’t about certifications or titles anymore. It was about doing the job well — with care and discipline.

COVID Changed My Routine Again

When the pandemic hit, life slowed down. No commuting. No social plans. I got back into a consistent morning routine: wake up at 5 AM, study until 7, then start work.

That year, I sat 12 certifications.

But more importantly, I built momentum. That led to me leading DevOps and SRE projects — and eventually transitioning fully into a DevOps role.

“Don’t explain your philosophy. Embody it.”
— Epictetus

The Final Push: Big Tech

At one point, I decided I wanted to break into Big Tech — Amazon, Google, Microsoft.

So I started studying 2–3 hours a day. Not because I had endless energy, but because I made a decision. I blocked out time. I protected that time.

No hacks. Just intention.

Studying Feels Like Levelling Up

Eventually, I started enjoying the process. Studying became like levelling up a character in a video game. Every new concept I understood felt like unlocking a new skill tree.

That mindset helped me stay consistent. Even when it felt boring. Even when I didn’t see progress.

“If a person gave away your body to some passerby, you’d be furious. Yet you hand over your mind to anyone who comes along.”
— Epictetus

Guard Your Focus

Lately, it’s been harder to focus. Social media — especially short-form content — makes it tough to sit still and learn.

But here’s the thing: the ability to focus is a skill now. And if you can build it, you already have an edge. While everyone else is scrolling, you’re building. I have some more thoughts on how our moms were right about the phone!

“The things you think about determine the quality of your mind.”
— Marcus Aurelius

So, How Do You Study With a Full-Time Job?

Here’s what worked for me:

• Time-block your mornings. Even 30–60 minutes is enough if you’re consistent.

• Study when your energy is highest. For me, that was mornings. For you, it might be evenings or lunch breaks.

• Have a clear goal. Not just “learn stuff,” but “get better at X,” or “prepare for Y.”

• Treat distractions like enemies. Your phone isn’t neutral — it’s a constant test of your discipline.

• Accept that it’s not supposed to be easy. It’s supposed to be worth it.

Final Thoughts

You don’t need a perfect setup to start. You just need to start.

I didn’t go to some fancy school. I worked nights at a gas station and delivered pizzas. I studied in the mornings before work and learned as I went.

The point isn’t to “hustle 24/7.” The point is to carve out some time, consistently, and use it with intention.

“Waste no more time arguing what a good man should be. Be one.”
— Marcus Aurelius

Because studying with a full-time job is hard. But so is staying in a role that doesn’t challenge you.

Choose your hard.

In this article, I'll show you how to deploy a FastAPI application to AWS Lambda using Mangum. Let's dive in!

Prerequisites

• Python 3.10 installed

• AWS account

• Basic understanding of FastAPI

• VS Code (or your favorite code editor)

Project Setup

First, let's create the directory for our project:

# Create project directory
mkdir fastapi-lambda-function 
cd fastapi-lambda-function

Create and activate virtual environment

python -m venv venv 
source venv/bin/activate  # On Windows: venv\Scripts\activate

Create two files in your project:

• requirements.txt

• main.py

In requirements.txt, add these dependencies:

fastapi==0.99.0  # Using this version due to current compatibility
mangum

Install the packages:

pip install -r requirements.txt

Creating Our FastAPI Application

In main.py, let's create a basic FastAPI app:

from fastapi import FastAPI
from mangum import Mangum

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello, this is my first FastAPI app running on AWS Lambda!"}

# Add another route for demonstration
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# This is the key for Lambda!
handler = Mangum(app)

This basic FastAPI has two endpoints, a root and pretty basic /items endpoint. But as you can see the last line with handler being Mangum, that is how AWS will trigger this Lambda function.

Packaging for AWS Lambda

Now comes the fun part - packaging our application for Lambda! We need to create a ZIP file containing all our dependencies and code.

On Windows you can use PowerShell:

# Zip dependencies
Compress-Archive -Path "venv/Lib/site-packages/*" -DestinationPath "aws-lambda.zip"

# Add main.py to the zip
Compress-Archive -Path "main.py" -Update -DestinationPath "aws-lambda.zip"

On Unix/Linux:

cd venv/lib/python3.10/site-packages
zip -r ../../../../aws-lambda.zip .
cd ../../../../
zip -g aws-lambda.zip main.py

Deploying to AWS Lambda

1. Go to AWS Console and search for Lambda

2. Click "Create function"

   

3. Choose "Author from scratch"

4. Configure the basics:

   • Name: fastapi-lambda

   • Runtime: Python 3.10

   • Architecture: x86_64

   • Default execution role: Create new basic Lambda role

     

5. Enable Function URL:

   • Click "Configuration" tab

   • Find "Function URL" and enable it

   • Auth type: NONE (for this demo)

   • Click "Save"

     

6. Upload your code:

   • Go to "Code" tab

   • Click "Upload from" and choose ".zip file"

   • Upload your aws-lambda.zip

   • Click "Save"

     

7. Configure the handler:

   • Go to "Runtime settings"

   • Click "Edit"

   • Change Handler to: main.handler

   • Click "Save"

Testing Your API

Once deployed, you'll get a Function URL. Try these endpoints:

• <your-function-url>/ - Should return your welcome message

• <your-function-url>/items/1 - Should return {"item_id": 1, "q": null}

• <your-function-url>/items/100 - Should return {"item_id": 100, "q": null}

What's Next?

This is just a basic example of what you can do with FastAPI and AWS Lambda. In production, you might want to consider:

• Setting up proper authentication

• Using API Gateway for more control

• Implementing proper error handling

• Setting up CI/CD pipelines

If you found this helpful, don't forget to follow me for more cloud and DevOps content! Check out my YouTube channel where I have a detailed video walkthrough of this tutorial.

Common Issues

• If you're getting errors with the latest FastAPI version, stick to version 0.99.0 as specified in the requirements.

• Make sure your handler name matches exactly main.handler.

• Check your Lambda execution role has proper permissions.

Happy coding!

P.S. All code from this tutorial is available in my GitHub repo.

What makes Uptime Kuma stand out is its simplicity. You get a clean, responsive UI, monitoring intervals as low as 20 seconds, and notifications through various services like - Telegram, Discord, Slack, email. Plus, it supports multi-language interfaces and lets you create multiple status pages, which is perfect if you're managing different projects.

Today, we're going to deploy Uptime Kuma to Google Cloud Platform using Terraform. Why GCP? Because their free tier is pretty generous, and with the setup we'll use, you can run this without spending a dime. And why Terraform? Because nobody wants to click through cloud console menus every time they need to set up their cloud infrastructure.

Let's get this monitoring system up and running!

Prerequisites

Before we dive in, make sure you have:

• A Google Cloud account with billing enabled

• Terraform installed on your machine

• Google Cloud CLI installed and authenticated

• A basic understanding of GCP and Terraform concepts

If you aren’t familiar with Terraform and GCP concepts or need a refresher, check out this free course on freeCodeCamp.

Project Setup

Let's start by creating a new directory for our Terraform configuration:

mkdir uptime-kuma-terraform
cd uptime-kuma-terraform

The Terraform Configuration

We'll need to create a single file named main.tf. This file will contain all our infrastructure configuration:

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
  }

  required_version = ">= 1.0.0"
}

provider "google" {
  project = var.project_id
  region  = var.region
}

# Create a persistent disk for Uptime Kuma data
resource "google_compute_disk" "kuma_disk" {
  name = "kuma-disk"
  type = "pd-standard"
  size = var.disk_size
  zone = var.zone
}

# Create VPC network firewall rule for Uptime Kuma
resource "google_compute_firewall" "kuma_firewall" {
  name    = "allow-kuma-3001"
  network = "default"

  allow {
    protocol = "tcp"
    ports    = ["3001"]
  }

  source_ranges = ["0.0.0.0/0"]
  target_tags   = ["kuma-3001"]
}

# Create the VM instance
resource "google_compute_instance" "uptime_kuma" {
  name         = "uptime-kuma-vm"
  machine_type = var.machine_type
  zone         = var.zone

  tags = ["kuma-3001"]

  boot_disk {
    initialize_params {
      image = "cos-cloud/cos-stable"
      size  = var.boot_disk_size
    }
  }

  attached_disk {
    source      = google_compute_disk.kuma_disk.self_link
    device_name = "kuma-data"
  }

  network_interface {
    network = "default"
    access_config {
      // Ephemeral public IP
    }
  }

  metadata = {
    google-logging-enabled = "true"

    # Configure the container
    gce-container-declaration = yamlencode({
      spec = {
        containers = [{
          name = "uptime-kuma"
          image = "registry.hub.docker.com/louislam/uptime-kuma:1-debian"
          securityContext = {
            privileged = false
          }
          volumeMounts = [{
            name = "kuma-data"
            mountPath = "/app/data"
            readOnly = false
          }]
          ports = [{
            containerPort = 3001
            hostPort = 3001
          }]
        }]
        volumes = [{
          name = "kuma-data"
          hostPath = {
            path = "/mnt/disks/kuma-data"
          }
        }]
        restartPolicy = "Always"
      }
    })

    # Format and mount the persistent disk
    startup-script = <<-EOF
      #!/bin/bash
      if [ ! -d "/mnt/disks/kuma-data" ]; then
        sudo mkdir -p /mnt/disks/kuma-data
        sudo mkfs.ext4 -F /dev/disk/by-id/google-kuma-data
        sudo mount -o discard,defaults /dev/disk/by-id/google-kuma-data /mnt/disks/kuma-data
        sudo chmod a+w /mnt/disks/kuma-data
      fi
    EOF
  }

  service_account {
    scopes = ["cloud-platform"]
  }
}

# outputs.tf
output "instance_external_ip" {
  value       = google_compute_instance.uptime_kuma.network_interface[0].access_config[0].nat_ip
  description = "The external IP address of the Uptime Kuma instance"
}

output "uptime_kuma_url" {
  value       = "http://${google_compute_instance.uptime_kuma.network_interface[0].access_config[0].nat_ip}:3001"
  description = "The URL to access Uptime Kuma"
}

Since, we have few variables within our main.tf , let’s create them in variables.tf

variable "project_id" {
  description = "The ID of the GCP project"
  type        = string
}

variable "region" {
  description = "The region to deploy resources to"
  type        = string
  default     = "us-central1"
}

variable "zone" {
  description = "The zone to deploy resources to"
  type        = string
  default     = "us-central1-a"
}

variable "machine_type" {
  description = "The machine type to use for the VM instance"
  type        = string
  default     = "e2-micro"
}

variable "disk_size" {
  description = "Size of the persistent disk in GB"
  type        = number
  default     = 20
}

variable "boot_disk_size" {
  description = "Size of the boot disk in GB"
  type        = number
  default     = 10
}

Now, create a terraform.tfvars file to specify your project ID:

project_id = "your-project-id"
# Optionally override other variables:
# region = "us-west1"
# zone = "us-west1-a"
# disk_size = 30
# machine_type = "e2-small"

What's Being Created?

Let's break down what this Terraform configuration is doing:

1. VM Instance: We're creating an e2-micro instance (free tier eligible) using Container-Optimized OS, which is perfect for running Docker containers.

2. Persistent Storage: A 20GB persistent disk is attached to store your Uptime Kuma data, ensuring your monitoring history and settings survive VM restarts.

3. Container Configuration: The VM is automatically configured to run the Uptime Kuma Docker container with proper volume mounting for persistent storage.

4. Networking: A firewall rule is created to allow traffic to Uptime Kuma's default port (3001).

Deployment

Now that our Terraform configuration is ready, let’s deploy our infrastructure.

1. First, initialize Terraform:

terraform init

2. Preview the changes that will be made:

terraform plan

3. Deploy the infrastructure:

terraform apply

When prompted, type yes to confirm. The deployment will take about 2-3 minutes.

Accessing Uptime Kuma

Once deployment is complete, Terraform will output your instance's IP address and the full URL to access Uptime Kuma.

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.

Outputs:

instance_external_ip = "34.71.97.11"
uptime_kuma_url = "http://34.71.97.11:3001"

Just open your browser and navigate to: http://<your-instance-ip>:3001

You'll see the Uptime Kuma setup screen where you can create your admin account and start monitoring your services.

Cleaning Up

If you ever want to tear down the infrastructure:

terraform destroy

Pro Tips

Here are some useful tips for managing your deployment:

1. Cost Management: The configuration uses free-tier eligible resources (e2-micro instance and standard persistent disk), so you shouldn't incur any charges if you're within the free tier limits.

2. Customization: You can easily modify the configuration by changing variables in your terraform.tfvars file:

   • Need more storage? Adjust disk_size

   • Want a more powerful VM? Change machine_type

   • Different region? Update region and zone

3. State Management: Keep your terraform.tfstate file safe - it's how Terraform tracks your resources. Consider using remote state for team environments.

Troubleshooting

If you can't access Uptime Kuma after deployment:

1. Wait a few minutes for the container to start up completely

2. Check if your VM is running in the GCP Console

3. Verify the firewall rule was created correctly

4. SSH into the VM to check container logs:

gcloud compute ssh uptime-kuma-vm
docker ps
docker logs $(docker ps -q)

Conclusion

And there you have it! You've just automated the deployment of Uptime Kuma on Google Cloud. No more manual configuration or clicking through the console - just clean, repeatable infrastructure as code.

The best part? This setup is completely free-tier eligible and takes care of all the little details like persistent storage and container configuration. You can now deploy and destroy your monitoring environment with a single command!

Let me know in the comments if you have any questions or run into issues. Happy monitoring! 🚀

Resources

• GitHub Repository with Terraform Code

• Uptime Kuma GitHub Repository

• Terraform Documentation

• Google Cloud Free Tier Details

Exam Overview

• Exam Code: AI-102

• Level: Intermediate

• Duration: 2 hours (with 1 hour 40 minutes for the actual exam)

• Number of Questions: ~50 (varies per exam)

• Passing Score: 700 out of 1000

Skills Measured

The exam covers six main sections:

• Plan and manage an Azure AI solution (15–20%)

• Implement content moderation solutions (10–15%)

• Implement computer vision solutions (15–20%)

• Implement natural language processing solutions (30–35%)

• Implement knowledge mining and document intelligence solutions (10–15%)

• Implement generative AI solutions (10–15%)

Exam Format and Tips

• Choose between Python or C# for SDK-related questions

• Access to Microsoft Learn is provided during the exam

• Time management is crucial - don't spend too long on any single question

Preparation Resources

1. Microsoft Learn: The primary resource for exam preparation

   • Course: "Designing and Implementing a Microsoft AI Solution"

   • Complete all modules, including hands-on labs

2. Official Study Guide: Available on Microsoft Learn

   • Provides a detailed breakdown of exam objectives

3. AI-102 Study Cram Course by John Savill

   • Offers a concise overview of exam topics and Azure AI services

     %[https://www.youtube.com/watch?v=I7fdWafTcPY&t=0s]

4. Hands-on Projects:

   • Build real Azure AI solutions to gain practical experience

   • Experiment with Azure AI Search, Cognitive Services, and other relevant technologies

5. Azure AI Services Familiarity:

   • Understand the use cases for various Azure AI services

   • Learn about recent rebranding (e.g., Cognitive Services now use "AI" in their names)

6. Docker Deployment:

   • Learn how to deploy AI services using Docker containers

   • Understand the setup process, including API keys and endpoints

My Personal Exam Experience

Time Management

The exam lasted the full two hours, and I used every minute available. In fact, time management turned out to be one of the biggest challenges. Despite my best efforts, I wasn't able to answer all the questions in time. When the clock ran out, I had left 2-3 questions unanswered at the very end. This experience taught me the importance of pacing myself throughout the exam and not spending too much time on any single question, trying to find right docs in Microsoft Learn.

Using Microsoft Learn During the Exam

Talking about the access to Microsoft Learn during the test, while this can be helpful, it's also a potential time sink. I found myself looking up information for some questions, which ate into my available time. In retrospect, I should have been more selective about when to use this resource. It's there to help, but relying on it too much can prevent you from finishing all the questions.

The Result

Despite the time crunch at the end, I'm happy to report that I passed the exam with a score of 760 out of 1000, close to the passing score of 700. The score report provided a breakdown of my performance in each section, which was helpful for identifying areas where I could improve further.

Lessons Learned

1. Time management is crucial: Practice working through sample questions under timed conditions to improve your pacing.

2. Use Microsoft Learn judiciously: While it's a valuable resource, be strategic about when you use it during the exam.

3. Focus on weaker areas: My score report showed that I performed least well in the "Plan and manage Azure AI solution" section. Identifying such areas can help you focus your continued learning and improvement.

Remember, everyone's experience will be unique, but I hope sharing mine gives you a better idea of what to expect and how to prepare.

Additional Tips

• Focus on solution-oriented scenarios in your study

• Practice identifying the appropriate AI service for different use cases

• Understand the differences between services like Azure AI Search and Azure AI Document Intelligence

• Familiarize yourself with both Python SDK and REST API interactions and how you can deploy AI services as containers

• Get used the important Microsoft Learn docs, makes it easy to navigate during the exam

Conclusion

With thorough preparation using the resources mentioned above and a focus on hands-on experience, you'll be well-equipped to pass the AI-102 Azure AI Engineer Associate certification. Good luck with your exam!

A Crisis of Distraction

The average 18-year-old in the U.S. is on track to spend a staggering 93% of their remaining free time staring at a screen. Imagine reaching the age of 90 and reflecting on a life dominated by digital distraction, missing out on real-world experiences, relationships, and personal growth. This isn't just about wasted time; it's about missed opportunities to shape who we become.

This image is fromDino Ambrosi's*Ted talk\**:*** The Battle for Your Time: Exposing the Costs of Social Media.

Here is where my mind was blown, if you take away Sleep, Work + School, Cooking/Eating and Bathroom away, an average 18 year old is going to have 334 months left as free time, given they live up to 90 years, out of which they are going to spend 312 months looking at screen!

The Cognitive Cost

Our brains are being rewired by the constant bombardment of short-form content and rapid-fire information. With the rise of TikTok, IG reel and YouTube Shorts, we're training ourselves to be chronically distracted, sacrificing our ability to focus, think deeply, and engage meaningfully with the world around us. This has serious implications for our careers, relationships, and overall well-being.

The Social Media Mirage

Social media platforms aren't just addictive; they subtly shape our values and beliefs. They tell us that our worth is tied to appearances, that relationships are about frequency over depth, and that complex issues can be reduced to sound bites. That's why we call them social media influencers, because they influence us. In contrast, technologies like books and letters encourage empathy, deep thought, and meaningful connection.

Paying with Our Lives

Is Social media FREE? No, Social media companies profit from our attention. We may not pay a monetary fee, but we pay dearly with our time, the most valuable resource we have. By understanding this dynamic, we can start to make more conscious choices about how we spend our digital hours.

The Unseen Addiction

While we grapple with the broader implications of screen time, the addiction itself remains largely unacknowledged. Within a mere 15 years, an astonishing 97% of Americans own a smartphone, and surveys indicate that roughly half feel addicted. American teens spend an average of nine hours a day on their phones, a significant portion of their waking lives.

Your Smartphone: A Dopamine Dealer

Smartphones are designed to trigger dopamine release through notifications, likes, and endless scrolling. This creates a cycle of craving and reward, making it hard to put the phone down.

This is image is from Macit, Hüseyin & Macit, Gamze & Güngör, Orhan. (2019). A Research On Social Media Addiction and Dopamine Driven Feedback. 5. 882-897.

The Cost of Connectivity

This addiction comes at a steep price. Research has linked excessive smartphone use to various mental health issues, including depression, anxiety, and even suicidal thoughts. Moreover, it's eroding our productivity, focus, and creativity. We're constantly distracted, interrupting deep work with a quick glance at our screens.

Read this great research by Sarhan AL: The relationship of smartphone addiction with depression, anxiety, and stress among medical students. SAGE Open Med. 2024 Feb 2;12:20503121241227367. doi: 10.1177/20503121241227367. PMID: 38313469; PMCID: PMC10838039..)

The Super Addiction

Smartphones are particularly insidious because they combine multiple addictive elements:

• Unlimited access: They're always in our pockets, available 24/7.

• Instant gratification: We get immediate rewards from likes, comments, and new content.

• Constant novelty: Apps are continuously updated to keep us engaged, with new ones like TikTok rapidly taking over entire generations.

• Social acceptance: It's the norm to be glued to our phones, making it harder to recognize the problem.

Calculate Your Screen Time Lifespan

Want to know how much of your life you might spend on screens? Try this simple formula:

(Daily Screen Time in Hours / 24) x (90 - Current Age) = Years Spent on Screens

For example:

If you're 30 years old, have a life expectancy of 90, and spend 5 hours a day on your phone screen:

(5 / 24) x (90 - 30) = 12.5 years on phone screen.

But wait, this number is still wrong, and it's probably going to be more than this, did you notice I am using 24 hours, so if you incorporate basic life tasks, like sleep, cooking, eating, etc, we have less than 24 hours in the day. To keep things simple, I am just going to subtract 8 hours of sleep from the day, which gives us:

(Daily Screen Time in Hours / 16) x (90 - Current Age) = Years Spent on Screens

(5 / 16) x (90 - 30) = 18.75 years on screens.

Again, this still an approximation but you get the idea, 18 years scrolling through endless reels/shorts! (at least most of it!)

Breaking Free: Steps Towards a Healthier Relationship

Most smartphones these days has Screen Time analytics, both iOS and Android have these features. Since I have an iOS device, I will be showing you how I have setup limits on some of the apps. And yes, if you want you can uninstall them too, but what I have found is, I still use some of these platforms to stay connected with my friends and family. Because the idea is to use the apps and not let these apps use us. I use them as Social Media apps not as doom scrolling apps.

There are two ways you can limit the screen time for these apps:
You can group them together, so let's say you want to limit TikTok, IG and X/Twitter usage to complete 30 minutes/day.

Or you can set individuals limits for each app, like in this example I have 30 minutes/day for each app: TikTok, IG and X/Twitter.

Again, make sure you don't get discourage by looking at the total hours, as applications like WhatsApp and Signal also come under the social umbrella (at least on iOS), which I use to connect: call and chat with my family and friends.

Again, the goal is to limit screen-time that is not valuable, talking to my mom on video chat is still very valuable to me!

So, keep these points in mind:

1. Limit screen time: Use apps to set boundaries and stick to them.

2. Digital detox: Schedule regular breaks from your phone, especially before bed.

3. Mindful usage: Pay attention to how your phone makes you feel and use it intentionally.

Conclusion

Smartphone addiction is not just about lost productivity; it's about losing ourselves in a digital world that's designed to keep us hooked. By recognizing the true cost of our screen time, we can make conscious choices to reclaim our time, attention, and lives.

Call to Action:

• Calculate your screen time lifespan: How many years will you spend on screens?

• Share this post with friends and family to raise awareness.

• Track your screen time and set goals for reducing it.

This blog post has a lot of references to research papers and also some talks. Please watch them.

• The Battle for Your Time: Exposing the Costs of Social Media by Dino Ambrosi

• Smartphones: It’s Time to Confront Our Global Addiction by Dr. Justin Romano

Want to impress potential employers and gain hands-on cloud experience at the same time? The Cloud Resume API Challenge is the perfect way to start! By building a cloud-based API for your resume, you'll showcase your cloud computing skills while creating something that has real-world value. And the best part – you don't need to be a cloud guru to get started.

Challenge Requirements:

• NoSQL Database: These flexible databases, like DynamoDB (AWS), Firestore (GCP), and Cosmos DB (Azure), are a great fit for storing resume data.

• Serverless Functions: This technology lets you run code without worrying about managing servers. It's the heart of your resume API!

• CI/CD (GitHub Actions): This tool automates the process of updating your API. Every time you change your code, GitHub Actions will repackage and redeploy it for you.

Step-by-Step Guide

Pick Your Cloud Playground: The Cloud Resume API Challenge supports AWS, Google Cloud Platform (GCP), or Microsoft Azure. Pick a provider that you like best!

Design Your Data: Think about what information your resume API will include. Start with the basics like your name, contact details, experience, and skills. You can always expand later!

Store your Resume Data: Use the NoSQL Database within your selected cloud provider to store your resume data in JSON.

Time to Code: Your core component will be a serverless function. This function is responsible for fetching your resume data from the database and crafting a response for anyone who uses your API.

Deploy to Cloud: Deployment is the process that makes your API accessible over the internet.

Test Drive Your API: Once your API is deployed, you (or anyone else!) can send a request and see your resume displayed in a structured JSON format.

Tips for Beginners

• Start Simple: Your initial API doesn't have to be fancy. Get the core functions working, then add features over time.

• The Power of Community: Visit the Cloud Resume API website to see examples from others who have taken on this challenge. You're not alone!

Ready to build your Cloud Resume API? My YouTube video has the detailed steps of the challenge.

Share Your Success: Did you conquer the challenge? I'd love to hear about it! Share your work and any questions in the comments below. Let's get started on your cloud journey!

My Journey

I was excited and a little nervous heading to the test center. The exam definitely challenged me, but walking out with a passing score of 737 felt amazing! I know I barely passed, as 700 is required passing score and also I barely finished in time, so managing those minutes is essential!

How Did I Prepare?

The big question, right? Here's the thing: I didn't use any traditional courses. Instead, I've been building projects on Azure for a while now, and that hands-on experience was my main study method. Here's what I focused on:

• Microsoft Learn Challenges: During the Microsoft Build Cloud Skills Challenge, I got a free exam voucher by completing the Microsoft Build: Cloud Development Challenge. It covered some of the AZ-204 modules.

• Microsoft Learn Modules: Outside of the challenge, I went through all the AZ-204 modules on Microsoft Learn. See them here.

• Hands-On Projects: This was the MOST important part! Over time, I've built projects on Azure that used the skills on the exam guide. Check out tools like Azure Functions, container apps, and storage accounts.

  

Important Extras

• The AZ-204 Exam Guide: Find it on the Microsoft website. Be super familiar with the skills you'll be tested on.

• Following are the domains you will be tested on with weightage:

  • Develop Azure compute solutions (25–30%)

  • Develop for Azure storage (15–20%)

  • Implement Azure security (20–25%)

  • Monitor, troubleshoot, and optimize Azure solutions (15–20%)

  • Connect to and consume Azure services and third-party services (15–20%)

• Open Book Option: Azure now lets you use Microsoft Learn during the exam! I found this useful, but be careful not to spend too much time searching for every answer.

My Advice?

• Build, build, build! Nothing replaces hands-on experience.

• Know the exam guide so you're building the right kinds of projects.

• Manage your time during the exam.

Not Just About the Badge

I'm proud to now be seven-times Azure certified, but it's the knowledge that matters most. I love challenging myself to learn through real-world problem-solving!

It's totally possible to pass the AZ-204 if you're focused on practical learning. If you have the time to invest in building projects, I believe you can do it!

Let me know your thoughts or questions in the comments!

So here is the quick answer: Yes, you should commit the .terraform.lock.hcl to your version control (GitHub repository).

Let's first see, what is the .terraform.lock.hcl. According to Hashicorp's documentation

Terraform automatically creates or updates the dependency lock file each time you run the terraform init command. You should include this file in your version control repository so that you can discuss potential changes to your external dependencies via code review, just as you would discuss potential changes to your configuration itself.

When terraform init is working on installing all of the providers needed for a configuration, Terraform considers both the version constraints in the configuration and the version selections recorded in the lock file.

If a particular provider has no existing recorded selection, Terraform will select the newest available version that matches the given version constraint, and then update the lock file to include that selection.

If a particular provider already has a selection recorded in the lock file, Terraform will always re-select that version for installation, even if a newer version has become available. You can override that behaviour by adding the -upgrade option when you run terraform init, in which case Terraform will disregard the existing selections and once again select the newest available version matching the version constraint.

Basically, .terraform.lock.hcl allows Terraform to keep on utilizing the version of the provider selected when you added it. In the event that you don't checkin the lock file, you will automatically be upgraded to the latest version, which may lead to broken changes.

Support multiple platforms

You may have developers who work with your Terraform code on different OS machines: Windows, macOS or Linux.
This is where you could choose to verify that all of your providers support all of those platforms, and to pre-populate the lock file with the necessary checksums, you can do so by running terraform providers lock and specifying those three platforms:

terraform providers lock \
  -platform=windows_amd64 \ # 64-bit Windows
  -platform=darwin_amd64 \  # 64-bit macOS
  -platform=linux_amd64     # 64-bit Linux

After the command has run successfully, you will also see that output mentions:

Review the changes in .terraform.lock.hcl and then commit to your version control system to retain the new checksums.

You can read more about the provider lock command here.

Terraform .gitignore file

And just for the reference, here is the Terraform .gitignore file.

# Local .terraform directories
**/.terraform/*

# .tfstate files
*.tfstate
*.tfstate.*

# Crash log files
crash.log
crash.*.log

# Exclude all .tfvars files, which are likely to contain sensitive data, such as
# password, private keys, and other secrets. These should not be part of version 
# control as they are data points which are potentially sensitive and subject 
# to change depending on the environment.
*.tfvars
*.tfvars.json

# Ignore override files as they are usually used to override resources locally and so
# are not checked in
override.tf
override.tf.json
*_override.tf
*_override.tf.json

# Include override files you do wish to add to version control using negated pattern
# !example_override.tf

# Include tfplan files to ignore the plan output of command: terraform plan -out=tfplan
# example: *tfplan*

# Ignore CLI configuration files
.terraformrc
terraform.rc

Hope you found this article helpful. I am Rishab, who loves writing and sharing content around cloud computing and DevOps. I also have a YouTube channel - Rishab in Cloud.

• GitHub Foundations

• GitHub Actions

• GitHub Advanced Security

• GitHub Administration

You can find more details on all four here.

GitHub Foundations Exam

According to GitHub, with this certification you highlight your understanding of the foundational topics and concepts of collaborating, contributing, and working on GitHub. This exam covers collaboration, GitHub products, Git basics, and working within GitHub repositories.

There are 7 domains in the exam, the official study guide can be found here.

• Domain 1: Introduction to Git and GitHub

• Domain 2: Working with GitHub Repositories

• Domain 3: Collaboration Features

• Domain 4: Modern Development

• Domain 5: Project Management

• Domain 6: Privacy, Security, and Administration

• Domain 7: Benefits of the GitHub Community

Registering for the exam

I came across this launch announcement by a tweet from Kedasha:

And immediately started looking at all the certifications that were offered. All of them are priced at $99 USD. As you can see in the tweet, for a limited time the GitHub Foundations Certification is on 50% discount, making the fee $49.50 USD.

So I decided to book my exam. You need to register an account on the certification site(you can use your existing GitHub account).

After registering, you can book the desired exam, it will ask for your personal info and take you to PSI, the test provider, where you will be able to choose if you want to take it Online or onsite at a test centre.

So, I booked my for 13th January, 2024, which was the very next day.

Preparation

I used Microsoft Learning path "GitHub Foundations" for my preparation. It had 14 modules, out of which I was able to complete 12 of them.

One other thing I would like to point out, my previous knowledge and experience with GitHub did help a lot, to sit this exam within a day. I have been using GitHub for 4-5 years now and have been maintaining and contributing to open-source projects.

Exam experience

There were about 75 questions on the exam and you have 120 minutes to complete the exam.

I took around 63 minutes to answer all the 75 questions. And I passed!

You immediately see if you passed or failed after you end the exam, and receive a score report and credly badge few minutes after you submit and end your exam. I scored 75% on the exam, but there was no score mentioned on the score report.

Questions and topics that I found challenging were:

• GitHub Administration and Security

• GitHub Enterprise Server and GitHub Enterprise Cloud

There were questions about Enterprise offerings and what authentication methods are supported on each, which I don't have much experience in. So will definitely recommend going over these offerings.

Hope this helps you with your preparations and I wish you luck if you are sitting the exam soon. I am thinking of taking the GitHub Actions Certification next, will let you know if I do take and will share my experience. You can find me on X/Twitter @rishabincloud or on LinkedIn if you have any questions.

1. Containerization: The Heart of Kubernetes

Before you dive into Kubernetes, understanding containerization is crucial. Containerization is the backbone of Kubernetes. It involves encapsulating an application in a container with its own operating environment. One of the most popular tools for this is Docker.

Understanding Docker:

• Dockerfile: This is a file containing instructions to build a container image.

• Building an Image: Use docker build to create the image from the Dockerfile.

• Running Containers: These images are blueprints for running your app in isolated environments.

• Example: Here is an example of a Dockerfile to containerize a Python Flask app.

    FROM python:3.8-slim-buster
  
    WORKDIR /python-docker
  
    COPY requirements.txt requirements.txt
    RUN pip3 install -r requirements.txt
  
    COPY . .
  
    CMD [ "python3", "-m" , "flask", "run", "--host=0.0.0.0"]
  

Docker is not just popular but also a standard in many tech stacks, as evidenced by its ranking in Stack Overflow surveys.

2. Cloud Basics: The Playground of Kubernetes

Most Kubernetes deployments are on cloud platforms. Familiarize yourself with the basics of cloud computing, especially with services from major providers like AWS (EKS), Azure (AKS), and Google Cloud Platform (GKE).

Key Cloud Concepts to Learn

• Virtual Machines

• Networking

• DNS

• Load Balancers

Understanding these will help you grasp how Kubernetes operates in a cloud environment.

3. YAML: The Language of Kubernetes

Kubernetes uses YAML (Yet Another Markup Language) to define and manage its configurations.

YAML in Action

• Defining Cluster State: Learn to write YAML to set up your Kubernetes deployments.

• Example: Here is a YAML file that creates ReplicaSet to bring 3 nginx pods.

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-deployment
      labels:
        app: nginx
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.14.2
            ports:
            - containerPort: 80
  

4. Networking Basics: The Connectivity of Kubernetes

Kubernetes is heavily reliant on networking. A basic grasp of networking concepts will significantly ease your Kubernetes journey.

Networking Concepts to Know

• OSI Model

• IP Addresses

• Networking Protocols

• Ports and DNS

Understanding these will clarify how Kubernetes pods, services, and external systems communicate.

Conclusion: Build Your Foundation First

My experience taught me that jumping into Kubernetes without these prerequisites can lead to unnecessary challenges. By first understanding containerization, cloud basics, YAML, and networking, you'll be better equipped to tackle Kubernetes.

Support and Further Learning

If you found this guide helpful, consider liking and sharing this article. Your likes and shares are greatly appreciated. Also, let me know in the comments if you're interested in a Docker course where I explain its workings and containerize a couple of apps.

Deploying Grafana to Azure’s Web Apps for Containers is a straightforward process:

• A storage account

• An Azure Files share

• Initiate an empty Sqlite database

• Web Apps for Containers Azure App Service

• Mount the Azure Files share

• Set an environment variable

Let’s get started.

Create a Storage Account

Begin by creating an Azure Storage account. This is where we will create the File Share later. You might ask, why do we need a File Share?

If I deployed Grafana as a container, the Sqlite database (and plug-ins) would be lost as soon as the container is reset. Hence, we will be using the File Share as storage for our Grafana database.

I have created grafana-rg as the resource group where all the resources will be deployed for this blog post. For the Storage Account, make sure you use a unique name and I went with Standard performance with Geo-Redundant Storage (GRS). I left everything else as default.

Create an Azure Files Share

Navigate to your newly created storage account and scroll down to File Shares.

Click on the + File share button.

For the Name, I chose grafana-storage you can choose whatever you like. I went with the Transaction optimized tier. Everything else was left to default.

Initiate an empty Sqlite database

I found it the hard way that if we leave Grafana to create the database, it will run into a database lock error. To overcome this, we’re going to create a Sqlite database manually and then, using the Azure CLI, we will upload the database to the file share.

On a Windows machine, you can run the following commands.

If you are on macOS, Sqlite is already installed and, therefore, you can skip the first command.

Also, you’ll need Azure CLI installed and authenticated with your Azure account.

choco install sqlite

sqlite3 grafana.db 'PRAGMA journal_mode=wal;'

Now, let's copy the grafana.db to our File Share. We will use the azcopy command.

az login az storage copy -s .\grafana.db -d https://<storage_account>.file.core.windows.net/<file_share> --subscription <subscription_name>

Replace <storage_account>, <file_share>, and <subscription_name>, with the appropriate values: the name of your storage account, the name of your file share and your subscription’s id or name.

App Service

Create a new Azure web application that publishes a Docker Container and choose Linux for the OS. Choose a pre-existing Linux App Service Plan or create a new one.

There is a Free F1 Plan, but I went with Basic B1.

For the Docker options, we’re going to leave the defaults for the moment. We’ll update this later once we have our environment fully configured. All other options we will the default.

Once the Azure Web App has been successfully configured, you can access it by the app service URL. You should see the nginx message.

Now we will configure the Web App container to use the Azure File Share as storage.

Mount the Azure Files share

In the Azure portal, on the App Service’s blade, click on Configuration, then Path mappings.

Now click on + New Azure Storage Mount.

Name the storage mount whatever you’d prefer and choose the Storage Account you created before, Azure Files for Storage Type, and the Azure File share created before for the Storage Container. Finally, most important, for the Mount path, type in /var/lib/grafana.

Click OK then Save at the top.

We just attached our Azure File share to our container and it will be mounted at /var/lib/grafana which is Grafana’s default file path for the database and its plugins. This means, should our container be restarted for any reason, none of our settings will be lost.

Set an Environment Variable

Now we have Grafana storing the database in our /var/lib/grafana mount path. However, it will not use the PRAGMA flag that we used earlier, therefore, we will experience database locking.

Grafana allows us to overwrite default configuration variables by leveraging environment variables. So, we’re going to use Grafana’s default database connection string, but append the necessary flag.

Click on the Configuration blade once again for your Web App(you should still be on the Configuration blade from the previous step).

Now, choose Application settings and add a + New application setting.

For the setting, enter the following:

Name: GF_DATABASE_URL
Value: sqlite3:///var/lib/grafana/grafana.db?cache=private&mode=rwc&_journal_mode=WAL

Leave the Deployment slot setting unchecked.

Make sure you click Save.

Awesome, now we have the environment configured, but we need to update our container’s image source.

In the App Service blade, under Deployment Center, choose Settings.

By default, the Full Image Name and Tag will be set to nginx(which was set when we created the App Service).

We want to use the Grafana Container Image, I have my own docker image for Grafana that I want to use, but you can use the default one that is provided by Grafana.

Curious on how to create your own Docker image, watch this video on how I did it.

Change the registry source to Docker Hub, and the image to grafana/grafana if you want to use the official Grafana Image.

Click Save.

It may take a moment for Azure to pick up the changes once you submit them. You can click Refresh a few times and check the logs to ensure the container was deployed correctly.

Now let's visit the Web App URL to see the changes.

Conclusion

We did it! We now have Grafana deployed to Azure Web Apps for Containers with Azure File Share as storage, making it redundant, not prone to losing data on container restarts and the ability to scale to support the necessary load.

In this blog post, I will share my experience and the resources I used to successfully pass the Linux Essentials certification. This certification is a fundamental level exam that provides a solid foundation in Linux. Whether you're new to Linux or pursuing a career in cloud security or cybersecurity, this certification can be highly beneficial. I will discuss the preparation process, the resources I utilized, and my overall exam experience.

Exam Objective

Here is the official Exam Objective for Linux Essentials:

1. The Linux Community and a Career in Open Source

2. Finding Your Way on a Linux System

3. The Power of the Command Line

4. The Linux Operating System

5. Security and File Permissions

Preparation and Background

I had been aiming to take the Linux Essentials certification exam since 2021. Although I prepared for the exam in 2022, I didn't sit for it until 2023. Having completed college courses on Linux fundamentals and advanced networking with Linux, I was already well-versed in Linux and the command line. Additionally, I had over three years of practical experience working with Linux daily, managing approximately 50 Linux servers in a cloud environment.

Resources Used

1. Jason Dion's Linux Essentials Course: I highly recommend this course, available on Udemy and included in the LinkedIn Learning subscription. For North American users, LinkedIn Learning can be accessed for free through public library memberships.

2. TryHackMe and Linux Journey: These platforms provide hands-on practice and a gamified learning experience. TryHackMe offers Linux fundamentals rooms, while Linux Journey provides an introduction to the command line and important Linux concepts.

3. Practice Exams: Day, a recommended creator, suggests Jason Dion's practice exams for additional preparation. Although I personally didn't go through any practice exams, they can be beneficial for beginners to assess their knowledge before the actual exam.

Exam Experience

I chose to take the exam at a nearby test center instead of at home. Having moved to an apartment close to a Pearson VUE test center, I found it more convenient. The exam consisted of 40 questions, and I had 60 minutes to complete it. However, I finished the exam in around 25 minutes. The passing score for this exam is 500 out of 800, and I scored 650. The exam fee was USD 120.

Conclusion

Obtaining the LPI Linux Essentials certification has been a valuable achievement. Linux is an essential tool in various fields, particularly in cloud and cybersecurity. Whether you're starting your career journey or looking to enhance your skill set, this certification can provide a solid foundation. In the future, I may explore additional Linux certifications. Stay tuned for more blogs and videos on useful Linux commands, the file system, and other relevant topics. Thank you for reading, and I hope you found this post helpful.

Feel free to reach me at rishabk7 on Twitter or Rishab Kumar on LinkedIn.

Have you ever played with LEGO blocks? If not, you still might know what they are. Those colorful, versatile bricks that let your imagination run wild? Sure, you have! We all love to build castles, robots, or spacecraft with them, right? Now, what if I told you there's something quite similar in the world of computers, and it's called Docker!

Hold up! You might be thinking, "What does Docker have to do with my LEGO blocks?" Well, let's embark on a journey to unravel this mystery!

Introduction

In our day-to-day life, we interact with many applications on our smartphones, tablets, or computers – games, educational apps, and a lot more. But have you ever wondered how these applications are created? They're built by software developers using different tools and languages. It's like constructing a LEGO masterpiece, but instead of physical blocks, they use blocks of code!

However, there's a challenge. Just like your LEGO creation might need a specific type of brick, these applications also need certain elements to work properly. When these applications are moved from one place to another (like from a developer's computer to a server in the cloud), they might not work correctly because some essential elements are missing or not compatible. It's like trying to fit your LEGO masterpiece into different rooms with different settings – some rooms might not have enough space or the right table for your masterpiece.

This is where Docker, the hero of our story, comes into play!

Understanding Docker

Docker is like a magical toolbox that provides a perfect environment (a room) for your application (LEGO masterpiece) to run. This toolbox is portable and can be carried anywhere. It ensures that no matter where you take it, the application will run just as intended, just like your LEGO masterpiece remains intact inside the box.

This magical toolbox is what we call a Docker Container. In technical terms, a Docker Container is a lightweight, standalone package that includes everything an application needs to run – code, runtime, libraries, and system tools. No matter where you move this container, the application will always run without any issues!

Now, Docker also has something called Docker Images. They're like the instruction manual that comes with your LEGO sets, telling you what pieces you need and how to put them together. In the same way, Docker Images provide the blueprint for creating Docker Containers.

Wrapping Up Our Adventure

So there it is, folks! Docker, in simple terms, is a fantastic tool that helps create and deliver software applications conveniently and reliably, just like transporting a LEGO masterpiece safely in a magic toolbox.

Although Docker sounds a bit technical, just remember that even the most complex things can be understood when related to something fun and familiar. Today, it's LEGO blocks and Docker, tomorrow it could be something else!

I am Rishab, feel free to reach out to me @rishabk7 on Twitter or @rishabincloud on IG. Also, I wrote this cheat sheet for Docker that you might find helpful.

Docker Command Line Interface (CLI) Commands

General Commands

• docker version: Need to check which Docker version you're running? This command will provide all the information.

• docker info: If you're looking for system-wide information related to Docker, this command is your go-to.

• docker help <command>: Are you uncertain about a specific command? Add the command after docker help to get detailed information.

Image Commands

• docker images: This command will provide a list of all the images present on your system.

• docker pull <image>: This command allows you to pull an image from a registry.

• docker rmi <image>: Use this command to remove one or images from your system.

Container Commands

• docker ps: List all running containers with this command.

• docker ps -a: List all containers, including stopped ones.

• docker run <image>: Use this command to run a command in a new container, pulling the image if needed and starting the container.

• docker stop <container>: Stop a running container.

• docker rm <container>: To remove one or more containers from your system.

Dockerfile Commands

• docker build -t <tag> .: This command lets you build an image from a Dockerfile in the current directory,

• docker tag <image> <tag>: You can tag an image to a name (local or registry) with this command.

Docker Compose Commands

• docker-compose up: This command builds, (re)creates, starts, and attaches to containers for a service.

• docker-compose down: If you want to stop and remove containers, networks, images, and volumes, use this command.

• docker-compose build: This command is used to build or rebuild services.

Dockerfile Instructions

Dockerfile instructions are used to assemble a Docker image. Here are some of the essentials:

• FROM: This sets the base image for subsequent instructions.

• RUN: This allows you to execute commands in a new layer on top of the current image and commit the results.

• CMD: This specifies the command to run when a container is launched.

• EXPOSE: You can inform Docker that the container listens on the specified network ports at runtime with this instruction.

• ENV: Set environment variables using this instruction.

• ADD/COPY: These instructions let you copy new files, directories, or remote file URLs and add them to the image filesystem.

• ENTRYPOINT: Configure a container that will run as an executable with this instruction.

• VOLUME: This creates a mount point and marks it as holding externally mounted volumes.

• USER: This sets the user name or UID used when running the image and for any following RUN, CMD, and ENTRYPOINT instructions.

• WORKDIR: This sets the working directory for any following RUN, CMD, ENTRYPOINT, COPY, and ADD instructions.

Lastly, it is always good practice to clean up and remove unused Docker resources. Docker provides a clean-up command for this: docker system prune. However, use this command with caution, as it will remove all unused resources.
For more in-depth information about Docker CLI commands and Dockerfile instructions, refer to the official Docker documentation.

This cheat sheet should serve as a handy reference guide whether you're a Docker newbie or a seasoned professional. I also made a PDF version which you can download here.
Free feel to reach out to me if you have any questions, I am @rishabk7 on Twitter and you can also find me on LinkedIn.

Today, I'll be sharing the resources and strategies that helped me pass the Google Cloud Associate Cloud Engineer exam. Whether you're new to the world of cloud and cloud certifications or have some experience, I hope you'll find these tips useful. I also have a video about the same and posts about other cloud certifications, so make sure to check those out too.

My Background and Motivation

Before I dive into the specifics, let me give you some context. I joined Google early in January 2022 and as part of my onboarding process within the Google Cloud team, I was required to get this certification within a certain timeframe.

Having worked in cloud computing for about two and a half years, with prior experience in AWS and Azure, I was not entirely new to cloud computing concepts. However, I did need to transfer my knowledge and experience over to the Google Cloud Platform.

I dedicated around 25-30 days to preparing for the exam and was able to pass it successfully. In this post, I'll share some of the resources that helped me along the way.

Resources That Helped Me

Official Google Resources

To start, I referred to the Associate Cloud Engineering Exam Guide, the official exam guide by Google. It helped me understand the different sections I needed to focus on, such as setting up a cloud solution environment, planning and configuring a cloud solution, deploying and implementing a cloud solution, ensuring the successful operation of a cloud solution, and configuring access and security.

Another official resource from Google is the Cloud Engineer Learning Path. This links to the Cloud Skills Boost Lab (formerly QwickLabs) which offers six courses and 25 hands-on labs. I highly recommend going through this learning path, as it offers invaluable hands-on experience.

Video-based Courses

For video-based courses, I opted for Coursera's "Preparing for Your Associate Cloud Engineer Journey" and their essential courses on cloud fundamentals and infrastructure scaling and automation. Note that these courses might be paid, but Google occasionally offers challenges that allow you to access some of these resources for free.

Alternatively, freeCodeCamp and Anthony have provided a comprehensive Google Associate Cloud Engineering course on YouTube, which is completely free.

Practice Exams

I highly recommend doing practice exams to familiarize yourself with the exam format and the type of questions you might encounter. I found Tutorial Dojo's practice exams to be particularly useful and reliable.

Text-based Resources and Flashcards

For those who prefer text-based resources or books, I recommend the "Google Cloud Certified Associate Cloud Engineer Study Guide" by Dan.

I also used Quizlet flashcards to help memorize and recall key concepts. Flashcards are an excellent study tool, and the Quizlet set by "christopher_gang" that I used included 213 flashcards covering various services relevant to the exam.

Conclusion

In conclusion, these were the resources that I relied on for my preparation. The entire process took me around 25 days. Remember, each person's journey is unique, and what worked for me might not work for you. However, I hope that sharing my experience will provide you with some guidance and inspiration as you prepare for your Google Cloud Associate Cloud Engineer exam.

Good luck with your exam and your journey in cloud and DevOps! Feel free to reach out to me on Twitter or LinkedIn.

Also, I made a video about my GCP Exam experience!

In this blog post, I'll share my experience taking the AWS DevOps Pro Exam, how I prepared for it, well I guess not prepared for it, and some recommendations for resources to help you pass the exam.

Preparation

Like the Azure DevOps Expert Exam (AZ-400), I didn't have any specific preparation for the AWS DevOps PRO Exam either. I had a coupon expiring and the exam version was retiring, so I decided to wing it.

That being said, I do have one year of DevOps engineering experience using TeamCity, CloudFormation, Terraform, and Azure DevOps, which helped me understand DevOps principles and where AWS tools fit in the process. However, I wasn't familiar with AWS-specific tooling, such as CodeCommit, CodePipeline, and CodeBuild.

My Exam Experience

I took the exam in person at a nearby college rather than doing it remotely from my home, via PearsonVUE. The exam took almost two and a half hours out of the three hours allotted, and I found it challenging to focus after the 30-35th question due to a lack of breakfast and a bad headache.

The questions were lengthier compared to the Azure DevOps Expert Exam (AZ-400), requiring more reading and remembering the context of the questions. Nevertheless, I passed the exam with a score of 756.

Recommendations for Exam Preparation

I suggest familiarizing yourself with all the DevOps tools offered by AWS, such as:

• CodeCommit, CodeBuild, CodeDeploy, CodePipeline

• CloudFormation

• Elastic Beanstalk

• SSM and OpsWorks

• There were also questions about CloudTrail, CloudWatch logs, monitoring, AWS Config, and AWS Inspector.

Understanding the concepts of fault tolerance, disaster recovery, and high availability is essential. If you have a strong understanding of the Software Development Lifecycle (SDLC) and have worked within a DevOps or Cloud team, you should be well-prepared for the exam.

Resources

Though I didn't use any resources for my preparation, I recommend checking out Stephen Marek's courses on Udemy for AWS certificate courses.

AWS Certified DevOps Engineer Professional 2023 - Hands On!

For practice exams, Tutorial Dojo/Jon Bonso's practice exams are a great option.

Conclusion

While I didn't prepare extensively for the AWS DevOps Pro Exam, my experience in the field and understanding of DevOps principles helped me pass. Remember that hands-on experience is invaluable when preparing for an exam like this. Good luck with your preparation, and I hope you find these insights helpful!

Bonus: If you are a video person, check out my YouTube Channel, where I talk about Cloud, DevOps and tech.

Feel free to reach out to me on Twitter or LinkedIn, if you have any questions.

Exam Objective

• Configure processes and communications

• Design and implement source control

• Design and implement build and release pipelines

• Develop a security and compliance plan

• Implement an instrumentation strategy

Prerequisite

In order to become a Microsoft Certified: DevOps Engineer Expert, you need either Azure Administrator Associate AZ-104 or Azure Developer Associate AZ-204.

Preparation

First of all, I have to admit that I got lucky to have a voucher for the exam, which I received after participating in the Microsoft Ignite Cloud Skills Challenge. Otherwise, the exam fee is around $165, which is not cheap. I booked the exam last year in November, for February 15th (this year), which was the last day to use the voucher. I did not prepare for the exam because I forgot that I had the exam on Feb 15th. Two days before the exam, I received an email from Pearson, the exam provider, reminding me of the upcoming exam, I thought I could not learn all the topics in such a short time.

I was surprised and nervous at the same time, as I did not expect the exam to be that close. I looked at the exam outline and realized that it was extensive, covering various aspects of DevOps practices and Azure services. However, I remembered that I had already gone through the Microsoft Learn modules when I participated in the cloud skills challenge back in November. That gave me some confidence as I had some background knowledge of the topics covered in the exam.

I also had one year of experience working as a DevOps Engineer with Azure DevOps as the primary tool for pipelines and continuous integration and deployment. That gave me a good understanding of how Azure services work together and how to configure them for different scenarios. Although I had not worked with Azure DevOps for some time, I could still remember the dashboard and some of the workflows I had set up.

Exam Experience

When I started the exam, I realized that some questions were challenging and required careful analysis and understanding of the scenarios. One area where I struggled was the different version control systems, such as Perforce and Apache Subversion, which I had not worked with before.

However, I managed to pass the exam with a score of 710 out of 1000, which was just above the passing score of 700. I did the worst in the Developer Security and Compliance Plan section, which I had not practiced before. I did the best in the Implement and Instrumentation Strategy section, which I was comfortable with because of my experience.

Although I managed to pass the exam without much preparation, I would not recommend anyone to take that risk. It is better to study and revise the topics covered in the exam, especially if you are not familiar with Azure services and DevOps practices. Also, make sure you practice the exam questions and understand the scenarios presented. A year of experience working with Azure DevOps and Azure services gave me some advantages, but that might not be the case for everyone.

Resources

Microsoft Learn is your best friend for any Azure certification.

Go through the AZ-400 Microsoft Learn module.

If you are looking for a video-based course, I don't have specific recommendations but highly suggest watching this playlist by John Savill:

If you are a video person, I also have a YouTube video talking about my experience with the exam.

In conclusion, passing the Microsoft Azure AZ-400 DevOps Engineer Expert exam requires a good understanding of Azure services and DevOps practices. With proper preparation and practice, anyone can pass the exam and earn the certification. If you have any questions about the exam or the certification, feel free to reach out to me on Twitter or LinkedIn.

Installing Pulumi

Since I am doing this demo on a macOS, it is easy with homebrew:

brew install pulumi/tap/pulumi

For Linux, here is the install script:

curl -fsSL https://get.pulumi.com | sh

If you are on Windows, you can download the MSI here.

After installation, here is the list of available commands:

@Rishabs-MacBook-Pro ➜ ~  pulumi
Usage:
  pulumi [command]

Available Commands:
  about          Print information about the Pulumi environment.
  cancel         Cancel a stack's currently running update, if any
  config         Manage configuration
  console        Opens the current stack in the Pulumi Console
  convert        Convert Pulumi programs from a supported source program into other supported languages
  destroy        Destroy all existing resources in the stack
  gen-completion Generate completion scripts for the Pulumi CLI
  help           Help about any command
  import         Import resources into an existing stack
  login          Log in to the Pulumi Cloud
  logout         Log out of the Pulumi Cloud
  logs           Show aggregated resource logs for a stack
  new            Create a new Pulumi project
  org            Manage Organization configuration
  package        Work with Pulumi packages
  plugin         Manage language and resource provider plugins
  policy         Manage resource policies
  preview        Show a preview of updates to a stack's resources
  refresh        Refresh the resources in a stack
  schema         Analyze package schemas
  stack          Manage stacks
  state          Edit the current stack's state
  up             Create or update the resources in a stack
  version        Print Pulumi's version number
  watch          Continuously update the resources in a stack
  whoami         Display the current logged-in user

Other Requirements

Make sure you have AWS CLI configured. You can read more on how to download and configure AWS CLI here.

And for the static website, I am using my terminal-portfolio as an example.

Deploying the site

Now, let's create a new directory for our project.

mkdir static-website && static-website

We'll be using pulumi new to initialize a new Pulumi project in my favorite programming language, Python.

pulumi new static-website-aws-python

Go through the prompts to configure the project.

It will ask you to either paste your access token or log in using your browser.

If you haven't created a Pulumi account, go ahead and hit enter, it will launch the browser and take you to the sign-in page. Sign-up for the Pulumi account.

After the account creation is complete, go back to your terminal, and you'll see that the authentication was successful.

Let's go through the project creation setup, after login is complete it will prompt you with project configurations:

Now you have a finished project that’s ready to be deployed, configured with the most common settings.

Also, let's inspect the code in __main__.py

import pulumi
import pulumi_aws as aws
import pulumi_synced_folder as synced_folder

# Import the program's configuration settings.
config = pulumi.Config()
path = config.get("path") or "./www"
index_document = config.get("indexDocument") or "index.html"
error_document = config.get("errorDocument") or "error.html"

# Create an S3 bucket and configure it as a website.
bucket = aws.s3.Bucket(
    "bucket",
    website=aws.s3.BucketWebsiteArgs(
        index_document=index_document,
        error_document=error_document,
    ),
)

# Set ownership controls for the new bucket
ownership_controls = aws.s3.BucketOwnershipControls(
    "ownership-controls",
    bucket=bucket.bucket,
    rule=aws.s3.BucketOwnershipControlsRuleArgs(
        object_ownership="ObjectWriter",
    )
)

# Configure public ACL block on the new bucket
public_access_block = aws.s3.BucketPublicAccessBlock(
    "public-access-block",
    bucket=bucket.bucket,
    block_public_acls=False,
)

# Use a synced folder to manage the files of the website.
bucket_folder = synced_folder.S3BucketFolder(
    "bucket-folder",
    acl="public-read",
    bucket_name=bucket.bucket,
    path=path,
    opts=pulumi.ResourceOptions(depends_on=[
        ownership_controls,
        public_access_block
    ])
)

# Create a CloudFront CDN to distribute and cache the website.
cdn = aws.cloudfront.Distribution(
    "cdn",
    enabled=True,
    origins=[
        aws.cloudfront.DistributionOriginArgs(
            origin_id=bucket.arn,
            domain_name=bucket.website_endpoint,
            custom_origin_config=aws.cloudfront.DistributionOriginCustomOriginConfigArgs(
                origin_protocol_policy="http-only",
                http_port=80,
                https_port=443,
                origin_ssl_protocols=["TLSv1.2"],
            ),
        )
    ],
    default_cache_behavior=aws.cloudfront.DistributionDefaultCacheBehaviorArgs(
        target_origin_id=bucket.arn,
        viewer_protocol_policy="redirect-to-https",
        allowed_methods=[
            "GET",
            "HEAD",
            "OPTIONS",
        ],
        cached_methods=[
            "GET",
            "HEAD",
            "OPTIONS",
        ],
        default_ttl=600,
        max_ttl=600,
        min_ttl=600,
        forwarded_values=aws.cloudfront.DistributionDefaultCacheBehaviorForwardedValuesArgs(
            query_string=True,
            cookies=aws.cloudfront.DistributionDefaultCacheBehaviorForwardedValuesCookiesArgs(
                forward="all",
            ),
        ),
    ),
    price_class="PriceClass_100",
    custom_error_responses=[
        aws.cloudfront.DistributionCustomErrorResponseArgs(
            error_code=404,
            response_code=404,
            response_page_path=f"/{error_document}",
        )
    ],
    restrictions=aws.cloudfront.DistributionRestrictionsArgs(
        geo_restriction=aws.cloudfront.DistributionRestrictionsGeoRestrictionArgs(
            restriction_type="none",
        ),
    ),
    viewer_certificate=aws.cloudfront.DistributionViewerCertificateArgs(
        cloudfront_default_certificate=True,
    ),
)

# Export the URLs and hostnames of the bucket and distribution.
pulumi.export("originURL", pulumi.Output.concat("http://", bucket.website_endpoint))
pulumi.export("originHostname", bucket.website_endpoint)
pulumi.export("cdnURL", pulumi.Output.concat("https://", cdn.domain_name))
pulumi.export("cdnHostname", cdn.domain_name)

So the template requires no additional configuration. Once the new project is created, you can deploy it immediately with pulumi up:

There will be a prompt, asking you if you want to perform this update, type yes and hit enter.

As you can see, it created 8 resources. And also gave us the following outputs:

Let's check out our static website by visiting the cdnURL which will looks something like this - https://d2384wrx9ddsro.cloudfront.net/.

Aye! We have a static website running on AWS!

Customizing the site

To customize the website to be my terminal portfolio, I am going to copy/clone the GitHub repository within our static-website directory.

So, this is what my directory structure looks like now:

And then using the pulumi config set, I am going to point to terminal-portfolio folder, instead of the www folder, with the path setting:

pulumi config set path terminal-portfolio

And then let's deploy the changes:

pulumi up

You can see that new changes have been deployed, but when you navigate to the CDN URL, it still might show the old "Hello, World!" website, that's due to the cache, by default, the generated program configures the CloudFront CDN to cache files for 600 seconds (10 minutes).

But we can change that!

Let's look at __main.py__ :

default_cache_behavior=aws.cloudfront.DistributionDefaultCacheBehaviorArgs(
        target_origin_id=bucket.arn,
        viewer_protocol_policy="redirect-to-https",
        allowed_methods=[
            "GET",
            "HEAD",
            "OPTIONS",
        ],
        cached_methods=[
            "GET",
            "HEAD",
            "OPTIONS",
        ],
        default_ttl=600,
        max_ttl=600,
        min_ttl=600,

You can change those values to your desired settings.

Let's check my terminal-portfolio again, by visiting the CDN URL - https://d2384wrx9ddsro.cloudfront.net

Voila!

In conclusion, Pulumi is a powerful tool for deploying and managing cloud infrastructure with ease. Whether you're new to Pulumi or have used it before, this blog post has shown you how to use it to deploy a static website to AWS.

Follow me here on Hashnode or Twitter/LinkedIn to stay up-to-date with my latest blog posts and tech tutorials.