Excursions

Modernizing Excursions: A Blog Redesign with Claude

Thu, 12 Mar 2026 00:00:00 +0000

This post was written by Claude (Anthropic’s AI assistant) as a documentation of the redesign process. This is a one-time AI-authored post — all future content on this blog will be written by the human behind Excursions.

The Starting Point
What Changed
The Process
Wrapping Up

The Starting Point

Excursions has been a home for notes on cloud infrastructure, DevOps, and systems reliability since 2020. Over the years, the design stayed functional but hadn’t kept up with modern web aesthetics. The typography felt dated, the layout was utilitarian, and dark mode was an afterthought with inconsistent contrast.

J decided it was time for a visual refresh — not a rewrite, but a thoughtful modernization of the existing Jekyll site. I (Claude) was brought in to pair on the implementation.

What Changed

The homepage got a new hero section with a concise tagline and quick-access links (About, GitHub, RSS). The navigation bar gained a glassmorphic effect — translucent with a backdrop blur that becomes solid on scroll. The font was swapped from IBM Plex Sans to Inter, with tighter letter-spacing on headings and a refined weight scale.

A new Popular section highlights three posts as gradient cards in a bento-style grid, selected based on actual site analytics. Article cards below received rounded corners, layered shadows, a subtle hover lift animation, and tag pills. Images now display at their natural aspect ratio — much better for technical screenshots.

The post page sidebar — showing Topics, Tags, and Related posts — was updated from a bordered box style to clean uppercase section labels with minimal dividers. Tags became pill buttons, and related posts are listed without bullets for a quieter visual.

The old three-column footer duplicated links already present in the header and hero section. It was replaced with a single row: copyright on the left, social links on the right. Clean and non-redundant.

Dark Mode

Dark mode was polished from the ground up — deep charcoal background, high-contrast body text (WCAG AAA), lighter card surfaces with subtle borders, and Material Blue 200 links for comfortable reading.

Small Fixes

Search box text was invisible on the transparent navbar — fixed with state-aware input colors
Pagination got pill-style buttons matching the overall design language
Scroll-based animations (fade-in) were added for article cards

The Process

The entire redesign was done in a single branch (revamp) over a few pairing sessions. No build tools or preprocessors were added — it’s still plain CSS, Bootstrap 5.3.3, and Jekyll. Changes were verified live with a local dev server, iterating on feedback in real time.

One recurring challenge was Jekyll’s dev server aggressively caching CSS files, which made it difficult to see updates. The workaround was moving some critical styles inline into HTML templates — a pragmatic solution that works reliably.

Wrapping Up

The blog now has a modern, cohesive look while keeping its lightweight foundation. No JavaScript frameworks, no build pipelines, no complexity creep — just cleaner CSS and better visual hierarchy.

This is the only post on Excursions written by an AI. Going forward, all content will be authored by J, as it has always been. Thanks for reading.

Policy-as-code for Infrastructure

Wed, 19 Jul 2023 00:00:00 +0000

If your infrastructure has been deployed and maintained as code, chances are that you might be using Terraform or CloudFormation.In those cases most probably the enforcement of policies is after thought or takes backseat.

Checkov is the tool with most common policies and checks, available as code to run and scan on the most Infrastructure as code files and return us misconfiguration or missing best practices.

The steps from Checkov Quick Start are straight forward and I see no point in repeating them here again.

In additon there is a scope for expanding the functionality of the basic tool by defining your own personal/enterprise rules as custom policies.

If you insist on better visualisation or centralised location to track the IAC scan results, they have provided a basic web visualization

Go ahead and give a try to see how compliant is your current Infrastructure as Code.

Few screenshots from my run on the cloud formation scripts from hereare below

Running checkov

Sample Result from the run

Track CloudFormation Stack Changes Using EventBridge

Wed, 09 Nov 2022 00:00:00 +0000

If you are handling your infrastructure as code using CloudFormation stacks and is managed by multiple users, you could have run into a scenario where one of them might have run the stack or modified the stack and no one is aware of change. To track and get alert on those scenarios we now have support for CloudFormation events in the EventBridge which can be piped to SNS or custom alert system.

Let us create a sample event to track Changes to one of the stacks. Most of the steps are clearly described here but the JSON here have few additional fields and statuses.

JSON for our custom event
EventBridge Rule

JSON for our custom event

Below JSON will help us in creating an alert for different statuses like

Creation Complete/Failed
Update Complete/Failed
Delete Failure

{
  "source": ["aws.cloudformation"],
  "detail-type": ["CloudFormation Resource Status Change"],
  "resources": ["arn:stack_Arn_here"],
  "detail": {
    "stack-id": ["arn:stack_Arn_here"],
    "status-details": {
      "status": ["CREATE_COMPLETE", "CREATE_FAILED", "UPDATE_FAILED", "DELETE_FAILED", "UPDATE_COMPLETE"]
    }
  }
}

EventBridge Rule

Open AWS EventBridge and create a new rule with Custom Pattern as shown in the screenshot below

Select your target which has to be SNS if you need to receive a notification

Once done create a rule and we should be good to receive the alert whenever a stack has been modified.

Classic Load Balancer migration to ALB

Sat, 16 Apr 2022 00:00:00 +0000

AWS EC2 Classic have already been retired and the official deadline for migration is coming up.

Although its not mentioned directly,the official recommendation is to use to the new Application/Network Load Balancers over the Classic Load Bakancers in VPC.

We have a quick migration option available in the AWS management console but is not useful for Projects and Infra which are deployed/maintained using the Infrastructure as Code.

In this post we will go through the steps necessary to perform the migration with zero downtime using Cloudformation templates on a sample application.

Note:This sample application and cloud formation templates are internet facing and required further configuration and testing before using in live or prodcution environments.

Steps inovlved in the migration
Prepare Sample application
Deploy ALB with out deletion of the Classic Load balancer
Clean Old Classic Load Balancer
Conclusion

Steps inovlved in the migration

Check and validate your existing Cloudformation template against exsiting Infrastructure.
Update the template with Application Load balancer changes.
Create new ALB while still serving traffic through the old Classic load balancer.
Slowly divert traffic to the new ALB.
Delete old classic load balancer using the Cloud formation.

I have executed above steps with a sample application and explained below

Prepare Sample application

The Cloudformation template here will create a Classic load balancer pointing to our sample application hosted on EC2.

The output of the same should be as below.

Deploy ALB with out deletion of the Classic Load balancer

This CF template will create a new Application load balancer which is going to replace our Classic load balancer created in step one.This is to ensure our new URL is ready and serving traffic before deleting the old endpoint.

The new URL should be serving our app.

Clean Old Classic Load Balancer

Once we are sure that the traffic is moved to the new URL i.e Application Load Balancer,we are good to run the last template which would delete our Classic Load Balancer.

Conclusion

Using this 3 step process we could easily migrate off from the Classic load balancer to Applcation load balancer with zero down time, which is very much need and appreciated on production environments.

Simple Ansible playbook to get the Linux host uptime

Wed, 02 Feb 2022 00:00:00 +0000

While working with EC2 Linux instances there could be a requirement to get the list of all the machines which had not been rebooted over months or for a particular number of days.The reason could be for audit or to the check the status of instances.

Assumptions
Script
What’s next

I have put together tasks to accomplish it as an Ansible Playbook below.

Assumptions

You have an working Ansible environment with a proper inventory file with all the details of hosts being managed.

Script

- name: Get the list of all the nodes which are running over a month
  hosts: all
  gather_facts: false
  tasks:

      - name: Show hostname for sanity check (or just use -v flag for verbose)
        command: hostname
        register: hostname
      - debug: var=hostname.stdout_lines

      - name: Check uptime prior reboot
        shell: cut -d ' ' -f1 /proc/uptime
        register: UPTIME_PRE_REBOOT

      - name: Setting fact for number of days
        set_fact:
          uptime_days: "{ { (UPTIME_PRE_REBOOT.stdout | int / 86400) | round(0) } }"

      - name: Hosts to be rebooted.
        debug:
          msg: " has not been rebooted since  days,which is older than a month"
        when: (uptime_days | int) > 30

This simple playbook fetches the uptime and converts to days,which can be used as condition.

What’s next

This script can be extended to take an action on the hosts which have not been rebooted.

Mitigating file system failures on root EBS volume

Mon, 20 Dec 2021 00:00:00 +0000

Below scenario explains the troubleshooting steps to get the EC2 recovered from EBS boot failiures.

Issue: System root has failed consistency check and instance was no longer able to boot.

Procedure to be followed for bringing the EC2 instance back.

Capture the current EBS volume metadata from AWS console,especially the device mount name.
Stop the EC2 instance which needs to be troubleshooted.
Detach the volume which has to be fixed from the AWS management console.
Use the same console to attach the volume to the rescue machine as a secondary device (/dev/sdf).
Check if the disk available on the rescue EC2 instance using

    lsblk

Run the fsck on the drive to fix the errors.

    fsck <mount>

Ex: fsck /dev/nvme2n1

If you see an error with the above command, run fsck directly.

    fsck

Above commands can be run with -N flag as a dry run to see the changes to be made.
Once the file errors are fixed,detach the EBS volume from the rescue EC2 instance and attach to the instance which has been taken down for maintenance.
Start the EC2 instance and check the system log.
If the process is successful we should be able to boot into the instance and the services would be running again.

This url has additional troubleshooting for EBS volumes.

Python sample script to fetch data from Jenkins API

Sun, 28 Mar 2021 00:00:00 +0000

While working with Jenkins,there was a requirement to collect details of the Jobs/builds that had been run on the Server and derive statistics like

Total Runs of a job:
Total Success:
Total Failures and etc.

There could be different approaches to capture the information and the UI also shows the few trends directly,but I took the help of Python and Jenkins API to get it done.

Jenkins API
Access token
Script
What’s next

Jenkins API

Jenkins provides REST Api which allows us to perform most of the actions and fetch the information which is usually available in the UI, programmatically.We can use the official Jenkins Builds URL and its corresponding api as an example to go through the options available.

Note: Do remember the official Jenkins server has restricted access to view build and job details from api.You should have full information available on your self hosted server though as shown below

Access token

Although the …./API/json details can be seen on the browser,you actually need configure an access token to capture them programmatically.So please go ahead and generate it using the steps already detailed on official guide

Script

Now lets come to the actual script which has been written in haste to complete the task, but it should be an useful snippet for a project to build up on.

For every URL we see in the Jenkins UI, we can append /api/json to see its JSON equivalent.In this script,we are fetching JSON data from the URL’s of the job and its executed builds.

First,we get the latest build ran and go through all its runs to get the statuses.So the complete script follows

import requests
import json

#Your jenkins URL and credentials goes here
url = 'https://jenkins-server.com/job/folder/job/Jobname/api/json'
username = 'username'
password = 'you access token'


#Use the 'auth' parameter to send requests with HTTP Basic Auth:
#Accessing the Job page to get the latest Build ran.
response = requests.post(url, auth = (username, password),verify=False)

try:
    buildnumberJson = json.loads(response.text)
except:
    print ("Failed to parse json")

if "lastBuild" in buildnumberJson:  
    totalbuilds = buildnumberJson["lastBuild"]
    runs = totalbuilds["number"]
    
else:
    print ("Failed to get build")

#Iterate over the job build runs to get the build status for each

totalsuccess = totalfailure = totalmissing = 0

for build in range(1,runs):
    buildurl= 'https://jenkins-server.com/job/folder/job/Jobname/api/json' + str(build) + '/api/json'
    print(buildurl)
    buildstatus = []
    try:
        response = requests.post(buildurl, auth = (username, password),verify=False)
        buildstatus = json.loads(response.text)
    except Exception as e:
        totalmissing =  totalmissing + 1  
    if "result" in buildstatus:
        if buildstatus["result"] == "SUCCESS" :
            totalsuccess = totalsuccess + 1
        if buildstatus["result"] == "FAILURE" :
            totalfailure = totalfailure + 1


#Generate Output numbers

print(f"total builds:{runs}")
print(f"total succeeded builds:{totalsuccess}")
print(f"total failed builds:{totalfailure}")
print(f"total skipped builds:{totalmissing}")

What’s next

This script can be extended to get details of the jobs on server and their success,time to run etc and build custom stats which are not available by default in Jenkins.Also we can start managing jobs programmatically with out manually logging into the console.

Voila:Host your Jupyter Notebook as webpage

Thu, 21 Jan 2021 00:00:00 +0000

Scenario: As a continuation from previous post here where users have to access a Jupyter Notebook to browse the files,we now have to create a website/webpage to have seamless experience hiding the code and notebook interface.

To achieve this we are going to use Voila, an opensource tool/extension.

Lets see how to build web server,serving the notebook.

Preparing EC2 to host Jupyter
Install Voila
Update Notebook
Launch Voila
Notebook as Webpage
Conclusion

Preparing EC2 to host Jupyter

We are going repeat the same steps in previous to have an EC2 with Jupyter prerequisites installed.

Create an EC2 to serve as a Bastion host with

Jupyter Notebook
AWS CLI
Python Boto3

This can be achieved by steps mentioned here

Install Voila

We will run voila server standalone with out using the extension,so proceed directly installing from Pip

pip3 install voila

Update Notebook

Update the earlier notebook with the below Python code to access the S3 files.This code will prompt user for the bucket name and lists all the files available.

from ipywidgets import widgets
import boto3

lbl1 = widgets.Label("Enter Bucket Name")
display(lbl1)
text1 = widgets.Text()
display(text1)
btn = widgets.Button(description = "List")
out = widgets.Output()

def list_files(_):    
    
    s3 = boto3.resource('s3')
    my_bucket = s3.Bucket(str(text1.value))
   
    with out:        
        out.clear_output()
        for my_bucket_object in my_bucket.objects.all():
            print(my_bucket_object.key)
        

    
btn.on_click(list_files)

widgets.VBox([btn,out])

Note that the code can be extended to show all the buckets and then asking the user to select the one he needs.

Launch Voila

Next, navigate to the folder where the notebook exists and launch voila.

voila

This will start a webserver hosting all the notebooks available.We can even add a Ngnix server in front of this service to serve multiple requests.

Notebook as Webpage

Once the link to notebook has been clicked,you would notice that Voila would run all the cells and gives an output as webpage.In our case it displays a text box and prompts for user input for bucket name.

Enter the bucket name and click List,you should have the required output

Please note that the burden to show the UI and widgets falls on us to ease the look and experience.In this example, i have used simple Ipywidgets to get the job done.we have a lot of complex available in the official Voila gallery here with their source code.

Conclusion

So, Using this we can make and serve simple web apps using Jupyter notebooks.This will be very useful when the users are not comfortable enough to run notebooks and we have limited time to create a webapp.

Browse and download S3 files with out public access to Bucket

Mon, 07 Dec 2020 00:00:00 +0000

Scenario: Users have to access and download files from a S3 bucket but not upload or change the contents of the same.

We can address the requirement by following official documented steps here

To make your bucket publicly readable, you must disable block public access settings for the bucket and write a bucket policy that grants public read access. If your bucket contains objects that are not owned by the bucket owner, you might also need to add an object access control list (ACL) that grants everyone read access.

But for my use case the bucket cannot be made public, users should be able to browse the files in S3 as good as any person with AWS login credentials with CLI or Python while retaining the read only access.

Hence, Jupyter Notebooks comes to my rescue to build a solution as described in this post.

Preparing EC2 to host Jupyter
Create S3 read only instance role
Create default Notebook
Download Files
Conclusion

Preparing EC2 to host Jupyter

Create an EC2 to serve as a Bastion host with

Jupyter Notebook
AWS CLI
Python Boto3

This can be achieved by steps mentioned here

At the end, we have a Jupyter notebook URL generated which users can access from any browser.

Create S3 read only instance role

Next create EC2 instance role with read only access policy for the S3 as below.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": ["arn:aws:s3:::my_bucket",
                 "arn:aws:s3:::my_bucket/*"]
        }
    ]
}

Attach this role to the EC2 and we are good to access all the S3 files from it.But wait we are not going to give EC2 access directly to the user.

Create default Notebook

Jupyter URL generated in the first step now act as a webservice running on our Bastion Ec2 and allows required S3 access to the users.

Now, to make the work easy for non-technical user.We can create a notebook with all the required S3 commands and save it in the default directory

The notebook has Commands to

Browse files in S3.
Copy files from S3 to temp directory on EC2 machine.

Download Files

Once we have followed all the steps, we should see our required file from the S3 available to download in temp directory.

Select the file, click download and we are good to use the file.

Conclusion

There might be better ways to achieve the same result and this could have downside of user misusing the EC2 machine.But at the end,it is quick and easiest solution I could put together and get working.

Also, Jupyter Hub can be used instead of notebook for more granular control and scaling for multiple users.

Managing EC2 AMI used in ECS clusters

Sun, 08 Nov 2020 00:00:00 +0000

People using EC2 backed ECS cluster can understand the pain which goes in to maintaining and patching the base machines running our ECS containers.We usually pick two paths

Use ECS optimized AMI maintained by AWS.
Use custom AMI with patching on our convenience.

Let us the see pros and cons with both the methods.

ECS optimized AMI images
Self managed ECS AMI
Finally

ECS optimized AMI images

Pros:

AWS updates base AMI periodically for us with latest security patches.
AWS regularly pushes AMI with updated ECS agent,Docker versions and dependencies.

Cons:

Older AMI’s disappears and will not available.
If you have hardcoded your Launch template/Configuration,cluster goes down when AMI is no longer available.
Compatibility issues may occur with the newer versions,especially in case of Windows Containers.

Solution to prevent hard coded AMI names using Terraform.

We can create Terraform resource as below to always fetch latest ECS optimized image provided by Amazon and then use it in our launch configuration or template

data "aws_ami" "windows" {
  most_recent = true
  owners      = ["amazon"]
  filter {
    name   = "name"
    values = ["Windows_Server-2019-English-Full-ECS_Optimized-*"]
  }
}

resource "aws_launch_configuration" "windows_ecs" {
  associate_public_ip_address = "true"
  enable_monitoring           = "true"
  iam_instance_profile        = "arn:aws:iam::XXXXXXXX"
  image_id                    = data.aws_ami.windows.id
  instance_type               = "t3.xlarge"
  key_name                    = "my key
  name_prefix                 = "ecs-windows"
  root_block_device {
    delete_on_termination = "true"
    encrypted             = "false"
    iops                  = "0"
    volume_size           = "50"
    volume_type           = "gp2"
  }

  lifecycle { create_before_destroy = true }
}

Self managed ECS AMI

Pros:

We can retain total control of ownership and maintenance of the AMI image.
We can enforce additional security and custom patching cycles.

Cons:

Obviously the burden to maintain the images falls on us.
AMI storage cost might increase depending on our versioning strategy.
Resources are required to pick latest ECS agent, docker version etc., test and update.

Finally

Whichever path we pick , the burden to change and upgrade our ECS cluster launch configuration falls on us.Although using and IAC like Terraform would make it easy to quickly update.

Do let me know if there are bette ways to maintain the AMI and EC2 backed ECS clusters.

Excursions

Modernizing Excursions: A Blog Redesign with Claude

The Starting Point

What Changed

Hero Section and Navigation

Popular Posts and Article Cards

Sidebar Modernization

Simplified Footer

Dark Mode

Small Fixes

The Process

Wrapping Up

Policy-as-code for Infrastructure

Track CloudFormation Stack Changes Using EventBridge

JSON for our custom event

EventBridge Rule

Classic Load Balancer migration to ALB

Steps inovlved in the migration

Prepare Sample application

Deploy ALB with out deletion of the Classic Load balancer

Clean Old Classic Load Balancer

Conclusion

Simple Ansible playbook to get the Linux host uptime

Assumptions

Script

What’s next

Mitigating file system failures on root EBS volume

Python sample script to fetch data from Jenkins API

Jenkins API

Access token

Script

What’s next

Voila:Host your Jupyter Notebook as webpage

Preparing EC2 to host Jupyter

Install Voila

Update Notebook

Launch Voila

Notebook as Webpage

Conclusion

Browse and download S3 files with out public access to Bucket

Preparing EC2 to host Jupyter

Create S3 read only instance role

Create default Notebook

Download Files

Conclusion

Managing EC2 AMI used in ECS clusters

ECS optimized AMI images

Self managed ECS AMI

Finally