Forem: Nikith

Using a Service Mesh in Kubernetes

Nikith — Tue, 23 Dec 2025 00:14:26 +0000

Introduction

Service meshes can automate the process of providing additional security, reliability, and functionality around your containers. In this tutorial, you will be able to see how a service mesh works up close by exploring how the service mesh interacts with a simple application.

Explore the Linkerd Dashboard

Copy the public IP address of the Kubernetes server from the lab.

Open a new browser Insert the public IP of Kubernetes server in place of in the web address below:

http://<****>:30080
Copy and paste the resulting address into your browser's address bar. This should bring you to the Linkerd dashboard for the Kubernetes cluster.

Under HTTP Metrics, click default. This should let you see our two deployments, which have not been meshed with Linkerd yet.

Mesh the Application with Linkerd

access the Kubernetes control plane node.

Get a list of the deployments in the default Namespace in YAML format, inject Linkerd's configuration into the YAML, and apply those changes using kubectl apply

kubectl get -n default deploy -o yaml | \
  linkerd inject - | \
  kubectl apply -f -

This should reconfigure the deployments so that Linkerd can inject the sidecar proxies.

changes made

pods are meshed

Explore the Changes to Application Components Made by Linkerd

View the list of Pods:

kubectl get pods

cloud_user@k8s-control:~$ kubectl describe pod terrapin-client-dep-666cf6cdfd-ghz29
Name:         terrapin-client-dep-666cf6cdfd-ghz29
Namespace:    default
Priority:     0
Node:         k8s-worker1/10.0.1.102
Start Time:   Mon, 22 Dec 2025 23:55:02 +0000
Labels:       app=terrapin-client
              linkerd.io/control-plane-ns=linkerd
              linkerd.io/proxy-deployment=terrapin-client-dep
              linkerd.io/workload-ns=default
              pod-template-hash=666cf6cdfd
Annotations:  cni.projectcalico.org/containerID: 8e32df1bf505e17d7dd7e84883d6fe56c9c0c5d48eb6df9e1eba7d5dace9b5b0
              cni.projectcalico.org/podIP: 192.168.194.81/32
              cni.projectcalico.org/podIPs: 192.168.194.81/32
              linkerd.io/created-by: linkerd/proxy-injector stable-2.11.1
              linkerd.io/identity-mode: default
              linkerd.io/inject: enabled
              linkerd.io/proxy-version: stable-2.11.1
              viz.linkerd.io/tap-enabled: true
Status:       Running
IP:           192.168.194.81
IPs:
  IP:           192.168.194.81
Controlled By:  ReplicaSet/terrapin-client-dep-666cf6cdfd
Init Containers:
  linkerd-init:
    Container ID:  containerd://0c1e6c79651831846eb35abd56353c8195b74192bab00f0442d4012bac4bb717
    Image:         cr.l5d.io/linkerd/proxy-init:v1.4.0
    Image ID:      cr.l5d.io/linkerd/proxy-init@sha256:60d12fbb0b4a53962a5c2a59b496b3ee20052d26c0c56fd2ee38fd7fae62146e
    Port:          <none>
    Host Port:     <none>
    Args:
      --incoming-proxy-port
      4143
      --outgoing-proxy-port
      4140
      --proxy-uid
      2102
      --inbound-ports-to-ignore
      4190,4191,4567,4568
      --outbound-ports-to-ignore
      4567,4568
    State:          Terminated
      Reason:       Completed
      Exit Code:    0
      Started:      Mon, 22 Dec 2025 23:55:04 +0000
      Finished:     Mon, 22 Dec 2025 23:55:04 +0000
    Ready:          True
    Restart Count:  0
    Limits:
      cpu:     100m
      memory:  50Mi
    Requests:
      cpu:        10m
      memory:     10Mi
    Environment:  <none>
    Mounts:
      /run from linkerd-proxy-init-xtables-lock (rw)
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-q45w2 (ro)
Containers:
  linkerd-proxy:
    Container ID:   containerd://79e2aee1789f786dbe749e0ee200afc8db2d33b46296d2d2c1da39204a44a5a4
    Image:          cr.l5d.io/linkerd/proxy:stable-2.11.1
    Image ID:       cr.l5d.io/linkerd/proxy@sha256:91b53d4b39e4c058e5fc63b72dd7ab6fe7f7051869ec5251dc9c0d8287b2771f
    Ports:          4143/TCP, 4191/TCP
    Host Ports:     0/TCP, 0/TCP
    State:          Running
      Started:      Mon, 22 Dec 2025 23:55:06 +0000
    Ready:          True
    Restart Count:  0
    Liveness:       http-get http://:4191/live delay=10s timeout=1s period=10s #success=1 #failure=3
    Readiness:      http-get http://:4191/ready delay=2s timeout=1s period=10s #success=1 #failure=3
    Environment:
      _pod_name:                                                terrapin-client-dep-666cf6cdfd-ghz29 (v1:metadata.name)
      _pod_ns:                                                  default (v1:metadata.namespace)
      _pod_nodeName:                                             (v1:spec.nodeName)
      LINKERD2_PROXY_LOG:                                       warn,linkerd=info
      LINKERD2_PROXY_LOG_FORMAT:                                plain
      LINKERD2_PROXY_DESTINATION_SVC_ADDR:                      linkerd-dst-headless.linkerd.svc.cluster.local.:8086
      LINKERD2_PROXY_DESTINATION_PROFILE_NETWORKS:              10.0.0.0/8,100.64.0.0/10,172.16.0.0/12,192.168.0.0/16
      LINKERD2_PROXY_POLICY_SVC_ADDR:                           linkerd-policy.linkerd.svc.cluster.local.:8090
      LINKERD2_PROXY_POLICY_WORKLOAD:                           $(_pod_ns):$(_pod_name)
      LINKERD2_PROXY_INBOUND_DEFAULT_POLICY:                    all-unauthenticated
      LINKERD2_PROXY_POLICY_CLUSTER_NETWORKS:                   10.0.0.0/8,100.64.0.0/10,172.16.0.0/12,192.168.0.0/16
      LINKERD2_PROXY_INBOUND_CONNECT_TIMEOUT:                   100ms
      LINKERD2_PROXY_OUTBOUND_CONNECT_TIMEOUT:                  1000ms
      LINKERD2_PROXY_CONTROL_LISTEN_ADDR:                       0.0.0.0:4190
      LINKERD2_PROXY_ADMIN_LISTEN_ADDR:                         0.0.0.0:4191
      LINKERD2_PROXY_OUTBOUND_LISTEN_ADDR:                      127.0.0.1:4140
      LINKERD2_PROXY_INBOUND_LISTEN_ADDR:                       0.0.0.0:4143
      LINKERD2_PROXY_INBOUND_IPS:                                (v1:status.podIPs)
      LINKERD2_PROXY_DESTINATION_PROFILE_SUFFIXES:              svc.cluster.local.
      LINKERD2_PROXY_INBOUND_ACCEPT_KEEPALIVE:                  10000ms
      LINKERD2_PROXY_OUTBOUND_CONNECT_KEEPALIVE:                10000ms
      LINKERD2_PROXY_INBOUND_PORTS_DISABLE_PROTOCOL_DETECTION:  25,587,3306,4444,5432,6379,9300,11211
      LINKERD2_PROXY_DESTINATION_CONTEXT:                       {"ns":"$(_pod_ns)", "nodeName":"$(_pod_nodeName)"}

      _pod_sa:                                                   (v1:spec.serviceAccountName)
      _l5d_ns:                                                  linkerd
      _l5d_trustdomain:                                         cluster.local
      LINKERD2_PROXY_IDENTITY_DIR:                              /var/run/linkerd/identity/end-entity
      LINKERD2_PROXY_IDENTITY_TRUST_ANCHORS:                    -----BEGIN CERTIFICATE-----
                                                                MIIBiDCCAS6gAwIBAgIBATAKBggqhkjOPQQDAjAcMRowGAYDVQQDExFpZGVudGl0
                                                                eS5saW5rZXJkLjAeFw0yNTEyMjIyMzM4NDlaFw0yNjEyMjIyMzM5MDlaMBwxGjAY
                                                                BgNVBAMTEWlkZW50aXR5LmxpbmtlcmQuMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcD
                                                                QgAE94d/0iTwQe7HZkt2fwFwSrietAUlwg9VwgCdeMYlaOrx30cj8+jy/fJJdEvH
                                                                sjsWl5HcG10FPn99fEulz4JmIKNhMF8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdJQQW
                                                                MBQGCCsGAQUFBwMBBggrBgEFBQcDAjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
                                                                BBRK/cAaNL05Lrepa6yUQxff49kfGTAKBggqhkjOPQQDAgNIADBFAiEAr1e+6hCh
                                                                kTBROQE6uDal2CRvtkl6rHOjLTOzueKIVPICIBQYOccdiDWTbEi4qWjhrX++aExU
                                                                bg9xL9dtUmhs9EVA
                                                                -----END CERTIFICATE-----

      LINKERD2_PROXY_IDENTITY_TOKEN_FILE:                       /var/run/secrets/kubernetes.io/serviceaccount/token
      LINKERD2_PROXY_IDENTITY_SVC_ADDR:                         linkerd-identity-headless.linkerd.svc.cluster.local.:8080
      LINKERD2_PROXY_IDENTITY_LOCAL_NAME:                       $(_pod_sa).$(_pod_ns).serviceaccount.identity.linkerd.cluster.local
      LINKERD2_PROXY_IDENTITY_SVC_NAME:                         linkerd-identity.linkerd.serviceaccount.identity.linkerd.cluster.local
      LINKERD2_PROXY_DESTINATION_SVC_NAME:                      linkerd-destination.linkerd.serviceaccount.identity.linkerd.cluster.local
      LINKERD2_PROXY_POLICY_SVC_NAME:                           linkerd-destination.linkerd.serviceaccount.identity.linkerd.cluster.local
      LINKERD2_PROXY_TAP_SVC_NAME:                              tap.linkerd-viz.serviceaccount.identity.linkerd.cluster.local
    Mounts:
      /var/run/linkerd/identity/end-entity from linkerd-identity-end-entity (rw)
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-q45w2 (ro)
  busybox:
    Container ID:  containerd://4d090b5d52f2ed1ee7b19d4172f203aea60837ae30c8136b9e063550dbd06d29
    Image:         radial/busyboxplus:curl
    Image ID:      sha256:4776f1f7d1f625c8c5173a969fdc9ae6b62655a2746aba989784bb2b7edbfe9b
    Port:          <none>
    Host Port:     <none>
    Command:
      sh
      -c
      while true; do curl -s terrapin-web-svc; sleep 5; done
    State:          Running
      Started:      Mon, 22 Dec 2025 23:55:07 +0000
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-q45w2 (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  kube-api-access-q45w2:
    Type:                    Projected (a volume that contains injected data from multiple sources)
    TokenExpirationSeconds:  3607
    ConfigMapName:           kube-root-ca.crt
    ConfigMapOptional:       <nil>
    DownwardAPI:             true
  linkerd-proxy-init-xtables-lock:
    Type:       EmptyDir (a temporary directory that shares a pod's lifetime)
    Medium:     
    SizeLimit:  <unset>
  linkerd-identity-end-entity:
    Type:        EmptyDir (a temporary directory that shares a pod's lifetime)
    Medium:      Memory
    SizeLimit:   <unset>
QoS Class:       Burstable
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type    Reason     Age    From               Message
  ----    ------     ----   ----               -------
  Normal  Scheduled  4m32s  default-scheduler  Successfully assigned default/terrapin-client-dep-666cf6cdfd-ghz29 to k8s-worker1
  Normal  Pulled     4m32s  kubelet            Container image "cr.l5d.io/linkerd/proxy-init:v1.4.0" already present on machine
  Normal  Created    4m30s  kubelet            Created container linkerd-init
  Normal  Started    4m30s  kubelet            Started container linkerd-init
  Normal  Pulled     4m29s  kubelet            Container image "cr.l5d.io/linkerd/proxy:stable-2.11.1" already present on machine
  Normal  Created    4m28s  kubelet            Created container linkerd-proxy
  Normal  Started    4m28s  kubelet            Started container linkerd-proxy
  Normal  Pulled     4m28s  kubelet            Container image "radial/busyboxplus:curl" already present on machine
  Normal  Created    4m27s  kubelet            Created container busybox
  Normal  Started    4m27s  kubelet            Started container busybox
cloud_user@k8s-control:~$

side car attached

Kubernetes GitOps with Flux

Nikith — Mon, 22 Dec 2025 19:45:32 +0000

Create a GitHub Personal Access Token

Open a new browser tab or window and navigate to github.com.
Create a new account and password on GitHub, or, if you already have a GitHub account, log in to GitHub.

In the upper right corner, click your avatar.
In the dropdown menu, click Settings.
In the left-hand menu, click Developer settings.
Click Personal access tokens.
Click the Generate a personal access token link.
If prompted, reenter your password and click Confirm password.
Under Note, enter a descriptive note for your personal access token (for example, acg-flux-lab).
Under Select scopes, click the check box next to repo.
Click Generate token.
Copy the generated personal access token.

Bootstrap the Git Repository

In the lab's server, bootstrap the Git repository. Be sure to substitute your own GitHub username where it says

flux bootstrap github --owner= --repository=acg-flux-lab --branch=main --path=./clusters/my-cluster --personal
This will create a new GitHub repository with the name acg-flux-lab.

When prompted, paste in your personal access token.

Return to the browser tab or window with GitHub.

Navigate to the web address github.com//acg-flux-lab. You should see you have a repository here that was created by Flux.

YAML MANIFEST

Create a Deployment via the GitHub Repository Using Flux

In your acg-flux-lab repository in GitHub, click Add files.

In the dropdown menu, select Create new file.

Enter clusters to create the file inside the clusters directory.

Enter my-cluster to create the file inside the clusters/my-cluster directory.

Enter turtle-deployment.yaml to name the file turtle-deployment.yaml.

Under Edit new file, put in the following YAML manifest:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: turtle-deployment
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: turtle
  template:
    metadata:
      labels:
        app: turtle
    spec: 
      containers:
      - name: nginx
        image: nginx:stable

!Initial](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/saq629ut5o4zdq3ak953.png)

Commit

kubectl get pods
kubectl get deployments

Reference

Exploring Log and Metric Data in Kubernetes

Nikith — Mon, 22 Dec 2025 18:50:59 +0000

Introduction

Observability is critical to any cloud native application. In this tutorial, you will be able to get hands-on with observability in Kubernetes. You will practice retrieving various kinds of metric data from a Kubernetes cluster.

Welcome to TortoiseCorp! We work to build the future of fruit, lettuce, and heat lamps.

We have an application running in the cluster, and we want to be able to retrieve some data about the application so that we can better understand how it is performing. You will need to retrieve the requested data about the application.

This will help us make some decisions about how we can continue to build and optimize our code!

Collect Logs from a Container

Collect logs from the container named lettuce from the Pod named food

kubectl logs food -c lettuce

Terminal

View Metric Data about Compute Resources Used by Pods

View metric data about the compute resource usage by the Pods in the default namespace:

kubectl top pods

From the list of Pods and their CPU usage, identify which Pod has the highest CPU usage by looking at the name of the Pod that has the highest value under CPU(cores).

Reference

https://app.pluralsight.com/

Deploying a Cloud Resource in AWS with Ansible and Terraform

Nikith — Fri, 19 Dec 2025 01:44:20 +0000

Ansible Approach

In this article, we will use Ansible to launch EC2 instances in different availability zones. The launch_ec2_instances.yml playbook defines three tasks: the first to get the subnet facts, the next to set the subnet IDs and availability zones, and a final task responsible for launching an EC2 instance into two specific subnets.

ssh cloud_user@<PUBLIC_IP_ADDRESS>

Launch EC2 Instances with YAML Playbook using Ansible

Launch in us-east-1
Copy the AMI ID into the image:<******> into the launch_ec2_instances.yml file

touch launch_ec2_instances.yml
vim launch_ec2_instances.yml

- name: Launch EC2 Instances
  hosts: localhost
  gather_facts: false
  vars_files:
    - /home/ansible/keys.yml

  tasks:
    - name: Get Subnet Facts
      ec2_vpc_subnet_info:
        aws_access_key: "{{ AWS_ACCESS_KEY_ID }}"
        aws_secret_key: "{{ AWS_SECRET_ACCESS_KEY }}"
        region: us-east-1
      register: subnet_facts

    - name: Set Subnet IDs and Availability Zones
      set_fact:
        subnet_ids: "{{ subnet_facts.subnets|map(attribute='id')|list }}"
        availability_zones: "{{ subnet_facts.subnets|map(attribute='availability_zone')|list }}"

    - name: Launch EC2 Instances in Each Subnet
      ec2:
        aws_access_key: "{{ AWS_ACCESS_KEY_ID }}"
        aws_secret_key: "{{ AWS_SECRET_ACCESS_KEY }}"
        ec2_region: us-east-1
        instance_type: t2.micro
        image: ami-026ebd4cfe2c043b2
        vpc_subnet_id: "{{ item }}"
        wait: true
      loop: "{{ subnet_ids }}"

Execute the Playbook
ansible-playbook launch_ec2_instances.yml
Since I had 2 subnets Two EC2 instances will be created

Terraform Approach

I used terraform data source.

You don’t rebuild the building, and you don’t change its structure you simply read where the walls, doors, and wiring already are so your new room fits perfectly.

In the same way, a data source lets Terraform look at existing infrastructure (like a VPC, subnet, or AMI) and use that information to safely build something new without disturbing what’s already there.

CONFIGURE AWS WITH CLI
installed packages

dnf install -y awscli

USED GITHUB CODESPACES

bash-5.1# cat /etc/os-release
NAME="Rocky Linux"
VERSION="9.3 (Blue Onyx)"
ID="rocky"
ID_LIKE="rhel centos fedora"
VERSION_ID="9.3"
PLATFORM_ID="platform:el9"
PRETTY_NAME="Rocky Linux 9.3 (Blue Onyx)"
ANSI_COLOR="0;32"
LOGO="fedora-logo-icon"
CPE_NAME="cpe:/o:rocky:rocky:9::baseos"
HOME_URL="https://rockylinux.org/"
BUG_REPORT_URL="https://bugs.rockylinux.org/"
SUPPORT_END="2032-05-31"
ROCKY_SUPPORT_PRODUCT="Rocky-Linux-9"
ROCKY_SUPPORT_PRODUCT_VERSION="9.3"
REDHAT_SUPPORT_PRODUCT="Rocky Linux"
REDHAT_SUPPORT_PRODUCT_VERSION="9.3"

main.tf

provider "aws" {
  region = "us-east-1"
}

data "aws_vpc" "selected" {
  id = "vpc-06110468de1ae8d0f"
}

data "aws_subnet" "selected" {
  vpc_id = data.aws_vpc.selected.id
  availability_zone = "us-east-1a"
}

data "aws_ami" "amazon_linux" {
  most_recent = true

  owners = ["amazon"]

  filter {
    name   = "name"
    values = ["amzn2-ami-hvm-*-x86_64-gp2"]
  }

  filter {
    name   = "state"
    values = ["available"]
  }
}

resource "aws_instance" "example" {
  ami           = data.aws_ami.amazon_linux.id
  instance_type = "t2.micro"

  subnet_id              = data.aws_subnet.selected.id
  vpc_security_group_ids = [aws_security_group.ec2_sg.id]

  tags = {
    Name = "terraform-ec2"
  }
}


resource "aws_security_group" "ec2_sg" {
  name        = "terraform-ec2-sg"
  description = "Allow SSH"
  vpc_id      = data.aws_vpc.selected.id

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

cli

bash-5.1# terraform apply
data.aws_vpc.selected: Reading...
data.aws_ami.amazon_linux: Reading...
data.aws_vpc.selected: Read complete after 0s [id=vpc-06110468de1ae8d0f]
data.aws_subnet.selected: Reading...
data.aws_subnet.selected: Read complete after 0s [id=subnet-00e24cf4555b3ca63]
data.aws_ami.amazon_linux: Read complete after 0s [id=ami-03f9680ef0c07a3d1]

Terraform used the selected providers to generate
the following execution plan. Resource actions are
indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # aws_instance.example will be created
  + resource "aws_instance" "example" {
      + ami                                  = "ami-03f9680ef0c07a3d1"
      + arn                                  = (known after apply)
      + associate_public_ip_address          = (known after apply)
      + availability_zone                    = (known after apply)
      + disable_api_stop                     = (known after apply)
      + disable_api_termination              = (known after apply)
      + ebs_optimized                        = (known after apply)
      + enable_primary_ipv6                  = (known after apply)
      + force_destroy                        = false
      + get_password_data                    = false
      + host_id                              = (known after apply)
      + host_resource_group_arn              = (known after apply)
      + iam_instance_profile                 = (known after apply)
      + id                                   = (known after apply)
      + instance_initiated_shutdown_behavior = (known after apply)
      + instance_lifecycle                   = (known after apply)
      + instance_state                       = (known after apply)
      + instance_type                        = "t2.micro"
      + ipv6_address_count                   = (known after apply)
      + ipv6_addresses                       = (known after apply)
      + key_name                             = (known after apply)
      + monitoring                           = (known after apply)
      + outpost_arn                          = (known after apply)
      + password_data                        = (known after apply)
      + placement_group                      = (known after apply)
      + placement_group_id                   = (known after apply)
      + placement_partition_number           = (known after apply)
      + primary_network_interface_id         = (known after apply)
      + private_dns                          = (known after apply)
      + private_ip                           = (known after apply)
      + public_dns                           = (known after apply)
      + public_ip                            = (known after apply)
      + region                               = "us-east-1"
      + secondary_private_ips                = (known after apply)
      + security_groups                      = (known after apply)
      + source_dest_check                    = true
      + spot_instance_request_id             = (known after apply)
      + subnet_id                            = "subnet-00e24cf4555b3ca63"
      + tags                                 = {
          + "Name" = "terraform-ec2"
        }
      + tags_all                             = {
          + "Name" = "terraform-ec2"
        }
      + tenancy                              = (known after apply)
      + user_data_base64                     = (known after apply)
      + user_data_replace_on_change          = false
      + vpc_security_group_ids               = (known after apply)

      + capacity_reservation_specification (known after apply)

      + cpu_options (known after apply)

      + ebs_block_device (known after apply)

      + enclave_options (known after apply)

      + ephemeral_block_device (known after apply)

      + instance_market_options (known after apply)

      + maintenance_options (known after apply)

      + metadata_options (known after apply)

      + network_interface (known after apply)

      + primary_network_interface (known after apply)

      + private_dns_name_options (known after apply)

      + root_block_device (known after apply)
    }

  # aws_security_group.ec2_sg will be created
  + resource "aws_security_group" "ec2_sg" {
      + arn                    = (known after apply)
      + description            = "Allow SSH"
      + egress                 = [
          + {
              + cidr_blocks      = [
                  + "0.0.0.0/0",
                ]
              + from_port        = 0
              + ipv6_cidr_blocks = []
              + prefix_list_ids  = []
              + protocol         = "-1"
              + security_groups  = []
              + self             = false
              + to_port          = 0
                # (1 unchanged attribute hidden)
            },
        ]
      + id                     = (known after apply)
      + ingress                = [
          + {
              + cidr_blocks      = [
                  + "0.0.0.0/0",
                ]
              + from_port        = 22
              + ipv6_cidr_blocks = []
              + prefix_list_ids  = []
              + protocol         = "tcp"
              + security_groups  = []
              + self             = false
              + to_port          = 22
                # (1 unchanged attribute hidden)
            },
        ]
      + name                   = "terraform-ec2-sg"
      + name_prefix            = (known after apply)
      + owner_id               = (known after apply)
      + region                 = "us-east-1"
      + revoke_rules_on_delete = false
      + tags_all               = (known after apply)
      + vpc_id                 = "vpc-06110468de1ae8d0f"
    }

Plan: 2 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

aws_security_group.ec2_sg: Creating...
aws_security_group.ec2_sg: Creation complete after 1s [id=sg-09d80c75597b8624d]
aws_instance.example: Creating...
aws_instance.example: Still creating... [00m10s elapsed]
aws_instance.example: Still creating... [00m20s elapsed]
aws_instance.example: Still creating... [00m30s elapsed]
aws_instance.example: Creation complete after 32s [id=i-07e8658ca12915abf]

Fetch VPC-ID

bash-5.1# aws ec2 describe-vpcs
{
    "Vpcs": [
        {
            "OwnerId": "080763862064",
            "InstanceTenancy": "default",
            "CidrBlockAssociationSet": [
                {
                    "AssociationId": "vpc-cidr-assoc-0c2a3ddbd5c6aa364",
                    "CidrBlock": "10.0.0.0/16",
                    "CidrBlockState": {
                        "State": "associated"
                    }
                }
            ],
            "IsDefault": false,
            "Tags": [
                {
                    "Key": "aws:cloudformation:logical-id",
                    "Value": "VPC"
                },
                {
                    "Key": "Name",
                    "Value": "LinuxAcademy"
                },
                {
                    "Key": "aws:cloudformation:stack-id",
                    "Value": "arn:aws:cloudformation:us-east-1:080763862064:stack/cfst-4150-d757e6fc0ddc7949940f7ec1f4710dd8b2bdf1fecd5f43946c84cb1649b24e2a/1d83daf0-dc6a-11f0-8dbd-123b45f64b33"
                },
                {
                    "Key": "Network",
                    "Value": "VPC"
                },
                {
                    "Key": "Application",
                    "Value": "cfst-4150-d757e6fc0ddc7949940f7ec1f4710dd8b2bdf1fecd5f43946c84cb1649b24e2a"
                },
                {
                    "Key": "UserId",
                    "Value": "24701544"
                },
                {
                    "Key": "aws:cloudformation:stack-name",
                    "Value": "cfst-4150-d757e6fc0ddc7949940f7ec1f4710dd8b2bdf1fecd5f43946c84cb1649b24e2a"
                }
            ],
            "BlockPublicAccessStates": {
                "InternetGatewayBlockMode": "off"
            },
            "VpcId": "vpc-0b76c79b6a607cb38",
            "State": "available",
            "CidrBlock": "10.0.0.0/16",
            "DhcpOptionsId": "dopt-079e42f1be6dd68a4"
        }
    ]
}

fetch subnet

                {
                    "Key": "aws:cloudformation:stack-name",
                    "Value": "cfst-4150-cf678142718819a066a9339ffe1e112471fc9e300512621571a366cc45a4129d"
                },
                {
                    "Key": "Application",
                    "Value": "cfst-4150-cf678142718819a066a9339ffe1e112471fc9e300512621571a366cc45a4129d"
                },
                {
                    "Key": "Network",
                    "Value": "Public2"
                }
            ],
            "SubnetArn": "arn:aws:ec2:us-east-1:143108796152:subnet/subnet-0dcaed3327867a837",
            "EnableDns64": false,
            "Ipv6Native": false,
            "PrivateDnsNameOptionsOnLaunch": {
                "HostnameType": "ip-name",
                "EnableResourceNameDnsARecord": false,
                "EnableResourceNameDnsAAAARecord": false
            },
            "BlockPublicAccessStates": {
                "InternetGatewayBlockMode": "off"
            },
            "SubnetId": "subnet-0dcaed3327867a837",
            "State": "available",
            "VpcId": "vpc-06110468de1ae8d0f",
            "CidrBlock": "10.0.2.0/24",
            "AvailableIpAddressCount": 251,
            "AvailabilityZone": "us-east-1b",
            "DefaultForAz": false,
            "MapPublicIpOnLaunch": false
        }
    ]

Successfully launched EC2 instance with terraform approach

References

Pluralsight Hands-on Lab – AWS / Cloud Infrastructure Lab https://app.pluralsight.com/hands-on/labs/4dd1d104-d54e-4351-bc6c-bc8be053ec42

7-Star Review: Switching from Windows to Mac Trackpad Review (With Real 16-Week Experience)

Nikith — Sun, 07 Dec 2025 03:31:17 +0000

Switching from Windows to Mac was something I expected to be simple, but I had no idea that the biggest upgrade wouldn’t be the UI, the apps, or even the ecosystem — it would be the trackpad.

In this honest, real-world Switching from Windows to Mac trackpad review, I’ll walk you through my 16-week experience, why I completely stopped using a mouse, and how the Mac trackpad became the most enjoyable part of my workflow.

My 16-Week Experience After Switching to Mac

I have used Windows laptops for years, so when I first touched the Mac trackpad, I had a feeling it would be different — but I didn’t expect it to be this different.

1. I No Longer Needed a Mouse

After about three to four weeks, something surprising happened:
I realized I hadn’t touched my mouse at all.

The Mac trackpad was so responsive and accurate that everything from coding, writing documents to extensive chrome usage became almost effortless.

It wasn’t just usable…
It was enjoyable.

2. The Seamless Feel

The first thing I noticed?
The trackpad feels butterly smooth (yes, I had to practice muscle memory with my fingers).

Gliding my fingers across it felt like sliding across polished glass with zero resistance.

3. Faster Than Expected

By week 16, I was navigating faster than ever before.
Gestures became second nature, especially:

Three-finger swipe to switch full-screen apps
Four-finger swipe for Mission Control
Pinch to zoom like using a smartphone
It made everything feel intuitive and natural.
The Magical Feel of the Mac Trackpad

Apple’s mac trackpad isn’t just a surface; it’s a precision tool.
The build and responsiveness create a satisfying “almost physical” feel because of the Haptic Engine underneath.

No moving parts (unlike most Windows laptops)
Uniform click sensation anywhere on the pad
Smooth, friction-balanced surface
Almost zero input delay
This explains why designers, programmers, and editors swear by it.

Gesture Controls That Changed My Daily Workflow

Two-Finger Pinch to Zoom

This is easily my favorite gesture.
It works exactly like a smartphone — pinch in, pinch out, effortlessly zooming photos, web pages, PDFs, or design layouts.

It feels so natural that switching back to a Windows laptop made me miss it instantly.

Two-Finger Tap → Extra Options

This simple gesture brings up extra options just like a right-click…
Except it's:

Softer
Faster
More reliable
No awkward pressure or clicking involved.

Smooth Scrolling

Mac scrolling feels alive.
Windows scrolling feels mechanical.

There’s no contest.

More Customizable Gestures in Trackpad Settings

macOS makes gesture customization incredibly easy:

Three-finger drag
Two-finger horizontal navigation
App Exposé
Desktop switching
Notification Center
Launchpad access
Force Click shortcuts

The menu is so simple that the customization takes seconds, not minutes.

Compared to Windows, where gesture menus vary by brand (Dell vs. HP vs. Lenovo), macOS is clean and consistent.

Force Touch Trackpads: Pressure Sensitivity That Windows Lacks

The Mac trackpad isn't just a multi-gesture tool it’s a pressure-sensitive device.

Apple’s Force Touch can detect different pressure levels, enabling:

Hard-press dictionary lookup
Force-click previews
Link previews in Safari
Timeline scrubbing in video apps

But here’s something even cooler:

An open-source macOS app called TrackWeight can read the pressure sensitivity — and display it in grams.

Yes, the trackpad can literally measure how hard you press.
Windows laptops simply don’t have an equivalent.

Windows trackpads have improved with Precision Drivers — but they’re still far behind.

How the Mac Trackpad Boosted My Productivity

Throughout my 16-week journey, the Mac trackpad helped me work faster:

Zooming instantly during editing
Switching desktops with gestures
Dragging files with three fingers
Browsing with soft two-finger taps
Navigating spreadsheets effortlessly

It removed the constant “move, click, reposition” dance that mice require.

My Favorite Gestures (Daily Use)

Two-finger zoom → For PDFs, design, browsing
Three-finger drag → For files and text selection
Four-finger swipe → Mission Control
Two-finger swipe → Back/forward in Safari
Force click → Quick previews

These gestures alone saved countless seconds every day.

Downsides & Learning Curve

Even with all the positives, there were a few hurdles:

One issue I noticed during my Switching from Windows to Mac trackpad review was the challenge of accurately selecting text using the traditional click-and-drag gesture. When I click and hold at the start of a sentence and slide my finger to highlight, the selection often jumps too far, starts in the wrong spot, or triggers a multi-page scroll. This makes it hard to select text with precision, especially when dealing with long paragraphs or code lines. To avoid mistakes, I often have to drag very slowly, which interrupts workflow and feels less efficient than using a traditional mouse. While macOS gestures are usually fluid and intuitive, text selection remains one of the few areas where the Mac trackpad still feels slightly unpredictable

It took about 1–2 weeks to adjust
Accidental gestures at first
Some apps don’t support Force Touch
Sensitivity tweaks needed early on
But everything became natural quickly.
Who Should Switch to the Mac Trackpad?

If you belong to any of these groups, the Mac trackpad will feel life-changing:

Students
Video/photo editors
Writers
Office professionals
Web developers
Creatives
Productivity enthusiasts

TrackWeight is open-source; you can find it on GitHub.

(Example external reference: https://github.com/ahkohd/TrackWeight
)

Conclusion

Switching from Windows to Mac changed how I work, but the biggest and most pleasant surprise was the trackpad. It’s not just more comfortable — it’s an entirely different interaction method.

From buttery-smooth gestures to pressure sensitivity and full customization, this trackpad proved itself to be more than a tool; it became my favorite part of the Mac experience.

The Day I Realized More Data Isn’t Better Data: Takeaways From Cribl’s SRE Webinar

Nikith — Wed, 19 Nov 2025 03:05:02 +0000

"3 Ways to Optimize Uptime, Observability Costs & Sanity"

It was a webinar hosted by Cribl discussing why most engineering teams struggle with data noise, slow insights, and rising telemetry costs, and how to fix it.

Reliability isn’t about more data; it’s about the right data in motion.

Alert fatigue is real. SRE and OPS teams are drowning in low-value alerts, false positives, and noisy telemetry that hides critical signals.

Too many tools/products result in more problems. Platform teams juggle monitoring stacks with inconsistent formats, fragile pipelines, and more misconfigurations to chase.

Infra/App teams run lean. With limited staff and tight budgets, gaps or delays in telemetry directly threaten uptime and SLA performance.

SRE Team Approach
(SRE at Cribl) shared how they stay focused on meaningful signals using:

·      Early filtering & drop rules to cut volumes before they reach costly storage

·      Aggregation & rollup metrics to match destination intervals

·      Sampling to reduce 80–99% of unnecessary logs

·      On-demand enrichment & routing via a central control plane

·      Real-time toggling of pipelines during incidents without re-deploys

·     Edge agents to collect only the data that matters, exactly when needed.

The SRE Team also mentioned the importance of Cribl Edge for smarter metrics collection.

Cribl SRE team uses Cribl Edge Crible Edge to simplify and scale metrics collection. It’s a great example of modern observability done right by following principles such as One agent for everything, Prometheus without the overhead, Logs & APIs become metrics.
Cribl Edge gives SREs & Platform Engineers a scalable, cost-efficient way to control observability data without modifying applications or deploying dozens of exporters.