Forem: Anand Kumar R

Stop Coding, Start Managing: A First Look at Google's AntiGravity IDE 🚀

Anand Kumar R — Mon, 24 Nov 2025 02:36:38 +0000

TL;DR: I took Google's new agentic IDE, AntiGravity, for a spin. It shifts the workflow from writing code to managing asynchronous agents. In this post, I break down how I built a Stock Dividend Tracker using Google Antigravity and Gemini 3, parallel task execution, and the tool's really cool feature: verifiable screen recordings.

The biggest difference in AntiGravity is the interface. While it has a traditional code editor (VS Code style) on the left, the right side is dominated by the Agent Manager.

Think of the Agent Manager as an autonomous coding engine. Instead of pair programming, you are assigning tasks.

The Inbox: This is your command center. You spin up tasks and check your inbox for status updates.
Modes: You can toggle between Planning Mode (for complex architecture) and Fast Mode (for quick fixes).
Models: You can swap models per task (e.g., using Gemini 3 for logic and a faster model for boilerplate).

The Killer Feature: Verifiable Artifacts 📹

We’ve all had an LLM tell us "Task Complete," only to run the code and watch it crash.

AntiGravity solves this with browser tool. When the agent claims it built a feature, it doesn't just show you the code—it proves it works.

Browser Control: The agent spins up a browser instance (you can see the "blue halo" indicating agent control).
DOM Interaction: It clicks buttons, enters data, and navigates the UI.
Screen Recording: It records a video of the test and analyzes that video to verify success.

In my demo, I asked it to build a Dividend Tracker. It didn't just write the API fetch; it opened the browser, added Apple and Microsoft stocks, verified the yield calculation, and sent me a video recording of the successful test.

The Workflow: Asynchronous & Parallel

Because the Agent Manager acts like an employee, you can multitask.

In the demo, I reached a point where the core app was working. I then issued two parallel tasks:

Thread A: Update logic to calculate total dividends based on share count.
Thread B: Create a visualization (Pie Chart) of the portfolio.

I sent both requests, stepped back, and monitored the Inbox. Both tasks ran simultaneously. The agent updated the implementation plan, modified the code, verified the output, and notified me when done.

Human-in-the-Loop Configuration

For those worried about an AI running rm -rf / on your machine, AntiGravity allows for granular permissions. You can set the Review Policy:

Always Approve: For low-stakes environments.
Ask for Approval: The agent pauses and asks permission before running CLI commands or critical file changes.
Auto-detect: The agent decides based on task complexity.

The experience felt less like "coding" and more like "code reviewing." I spent my time editing the Task List and Implementation Plan documents rather than wrestling with syntax.

Final Thoughts

AntiGravity represents a shift from writing software to architecting software. The ability to trust the output because of the verifiable artifacts (screen recordings) is a massive step forward in reducing the friction of AI development.

Check out the full video below to see the agent driving the browser in real-time!

Have you tried Agentic workflows yet? Let me know in the comments!

Create Your First Google ADK Agent: A Beginner's Guide

Anand Kumar R — Thu, 13 Nov 2025 18:43:07 +0000

In this tutorial, we'll walk through how to create your first agent using Google's Agent Development Kit (ADK). We'll explore two primary methods: using the intuitive Visual Builder and a straightforward, no-code YAML configuration.

Understanding the Anatomy of an ADK Agent

Before we build, let's break down the core components of a Google ADK agent:

Name: A unique identifier for your agent.
Model: The engine powering your agent. This can be a first-party Google model (like Gemini) or any third-party/open-source model via the LightLLM integration.
Instructions: This is where you define the agent's persona, its core logic, and the desired output schema. Think of it as a detailed, structured prompt.
Description: A concise summary of the agent's purpose. This is crucial in multi-agent systems, where agents interact based on each other's descriptions.
Tools: These equip your agent with external capabilities. ADK provides several built-in tools like Google Search and File Retrieval. You can also integrate with third-party tools (LangChain, CrewAI) or build your own custom logic using a Function Tool.

Prerequisites

Get a Gemini API Key: You'll need a Gemini API key for this project. Create a .env file in your project root and add your key:
```
GEMINI_API_KEY="YOUR_API_KEY_HERE"
```

Set up a Virtual Environment:

python -m venv .venv
source .venv/bin/activate

Install or Upgrade Google ADK: The Visual Builder requires version 1.18 or higher.
```
pip install --upgrade google-adk
```

Method 1: Create an Agent with the Visual Builder & AI Assist

The fastest way to get started is with the ADK web interface and its natural language capabilities.

Launch the ADK Web Console:
```
adk web
```
Create a New Agent: In the web UI, select "Create a new agent in visual mode" and give it a name (e.g., Visual-Agent-1).
Use the AI Assistant: On the right-hand side, you'll find an assistant. Let's give it a prompt to create a research agent.

Prompt: "Create a bull and bear research agent for a given stock. It should use Google Search to analyze the bull and bear cases for the stock and return a summary in a bulleted list."

The assistant will generate the necessary YAML configuration.
Save and Test: Once you approve the generated YAML, the agent's instructions and the required GoogleSearch tool will be auto-populated. Save the agent and test it directly in the UI by providing a stock ticker like "Nvidia".

The agent will now perform a search and return a formatted analysis of the bull and bear cases for the stock.

Method 2: Create an Agent with YAML Configuration

If you prefer a code-free, configuration-driven approach from the start, you can use the CLI.

Run the create Command: Use the adk create command with the --configuration flag.
```
adk create --name "My-YAML-Agent" --configuration
```
Follow the Prompts: The CLI will guide you through a series of questions to set up your agent:
- Select the model you want to use (e.g., gemini-2.5-pro).
- Choose the provider (e.g., Google AI).
- Enter your API key.
Agent Created: This process generates a root_agent.yaml file with a minimal configuration. You can now run adk web to test it or begin customizing the YAML file with more detailed instructions and tools.

And that's it! You've successfully created your first ADK agent using three different approaches: the AI-assisted builder, the visual workflow, and the no-code YAML configuration. In future posts, we'll dive into more advanced concepts like multi-agent systems and callbacks.

Short videos

(Google ADK Visual Builder)- https://youtube.com/shorts/fIv6fvUM3gg?si=6U_DeU2NRXFaBy8M

(Anatomy of a Google Agent Development Kit (ADK) Agent) - https://youtube.com/shorts/pkttZnC5DCU?si=DvaLy5Z-F1Tg1EgQ

Gemini CLI Custom Slash Commands

Anand Kumar R — Fri, 07 Nov 2025 20:19:23 +0000

Are you looking for a way to make your command-line experience with Gemini CLI more powerful and personalized? If you're performing repetitive tasks, then it's time for you to discover the magic of custom slash commands.

To help you with that, I've created a step-by-step video guide that breaks down how you can create your own slash commands to automate just about anything. I believe it's a total game-changer for streamlining your development workflow.

Check out the full video I made for you here:

What are Slash Commands?

Slash commands are custom shortcuts you can create in the Gemini CLI. Instead of typing out long, complex commands, you can define a simple /your-command-name to execute a script or a series of instructions. Think of them as personalized macros for your CLI.

Key Takeaways from My Video

I've packed my guide with practical information, but here are some of the highlights I'll walk you through:

Introduction to Custom Commands: I'll give you a clear overview of what they are and why they are so useful.
Step-by-Step Creation: I'll guide you through the entire process of creating your first command from scratch.
Dynamic Arguments: You'll learn how to make your commands flexible by passing arguments, allowing them to handle different inputs and scenarios.
Organizing with Namespaces: As you build more commands, keeping them organized is key. I'll show you how to group related commands using namespaces.
Pre-built Commands Repository: If you don't want to start from zero, you can tap into a repository of pre-built commands to get started even faster.

Why You Should Try This

Automating repetitive tasks is one of the best investments you can make in your productivity. By creating your own slash commands, you can:

Save Time: Execute complex operations in seconds.
Reduce Errors: Avoid typos and mistakes from re-typing long commands.
Share Workflows: Easily share your custom commands with your team to standardize processes.

I made this video to be a perfect starting point for anyone looking to level up their Gemini CLI skills.

I hope you enjoy it. Happy coding!

Google's Unified Gen AI SDK: A Hands-on Guide

Anand Kumar R — Tue, 11 Mar 2025 12:03:39 +0000

Google's Unified Gen AI SDK: A Hands-on Guide

Introduction

If you prefer learning visually, here is a YouTube Video I created for the same article:

If you've been working with Google's Generative AI model Gemini, you might have encountered a frustrating challenge: using different client libraries for the Gemini Developer API and the enterprise version on Vertex AI. While these libraries were similar, they weren't interchangeable, meaning that moving from experimentation to production required code rewrites.

Google's new unified Gen AI SDK solves this problem by providing a single library that works seamlessly with both Gemini 2 and 1.5, across both developer and enterprise environments.

In this guide, we'll explore three key methods for leveraging this SDK:

Generate content
Generate streaming content
Chat client

Let's dive in and see how this unified SDK simplifies working with Google's generative AI capabilities.

Getting Started

First, let's install the SDK using pip:

# Install the Google Gen AI SDK
pip install google-generativeai

For Developer API

If you're using Google Colab, you can find your API key under the secrets section by clicking on "Import key from AI Studio." If you're not using Colab, you can generate a free API key at aistudio.google.com.

from google import genai
from google.colab import userdata
from IPython.display import Markdown, display

GOOGLE_API_KEY = userdata.get('GOOGLE_API_KEY')

# Create a client instance using Google Gemini API Key
client = genai.Client(api_key=GOOGLE_API_KEY)

response = client.models.generate_content(
    model='gemini-2.0-flash', 
    contents='Create a short bedtime story for a 7 year old using unicorn and rainbows'
)
display(Markdown(response.text))

For Vertex AI (Enterprise)

For the enterprise version on Vertex AI, you would use the same code after authenticating to Google Cloud and provide your GCP project ID:

# Authenticate to Google Cloud 
gcloud auth application-default login

# Provide project details
from google import genai
from IPython.display import Markdown, display
from google.colab import userdata

PROJECT_ID = userdata.get('PROJECT_ID')
LOCATION = userdata.get('LOCATION')

# Create a client instance using Vertex AI in Google Cloud
client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
    model='gemini-2.0-flash', 
    contents='Create a short bedtime story for a 3 year old using unicorns and rainbows'
)
display(Markdown(response.text))

With the unified SDK, the code is identical whether you're using the developer API or Vertex AI. The only difference is in the initial setup.

Generate Streaming Content

If you prefer a streaming response that delivers content chunk by chunk:

response = client.models.generate_content_stream(
    model="gemini-2.0-flash",
    contents=["Create a poem with unicorns and rainbows"])

for chunk in response:
    print((chunk.text), end="")

The streaming approach can provide a more interactive user experience, especially for longer responses.

Chat Client

The chat client method maintains conversation history and context, making it ideal for interactive applications:

Turn 1

chat = client.chats.create(model="gemini-2.0-flash")
response = chat.send_message("I want to play a tic tac toe game. I selected top right as X. Your turn")

print(response.text)

Turn 2

response = chat.send_message("ok, I go bottom right as X")
print(response.text)

You would see that the response from the LLM maintains the context from the previous conversations.

Customizing Configuration Parameters

By default, the SDK uses a set of standard configurations. However, you can modify these to suit your needs:

from google import genai
from google.genai import types

PROJECT_ID = userdata.get('PROJECT_ID')
LOCATION = userdata.get('LOCATION')

# Create a client instance using Vertex AI in Google Cloud
client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
    model='gemini-2.0-flash',
    contents='Create a short bedtime story for a 3 year old using unicorns and rainbows',
    config = types.GenerateContentConfig(
        max_output_tokens=200,
        temperature = 0.1)
)
display(Markdown(response.text))

Using System Instructions

System instructions help define the persona of your client instance:

# Set system instructions to define a persona
sys_instruct = "You speak like a short tempered pirate"
response = client.models.generate_content(
    model='gemini-2.0-flash',
    contents='Create a short bedtime story for a 3 year old using unicorns and rainbows',
    config = types.GenerateContentConfig(
        systemInstruction=sys_instruct
        )
    )

display(Markdown(response.text))

This can be useful for creating specialized agents with specific personalities or expertise.

Conclusion

Google's unified Gen AI SDK significantly simplifies the process of working with Gemini models across both development and production environments. With a consistent API for generating content, streaming responses, and maintaining chat sessions, developers can now experiment freely and move to production without the pain of code rewrites.

The SDK also provides extensive customization options through configuration parameters and system instructions, allowing for fine-tuned control over model behavior.

In upcoming articles, we'll explore more advanced features of the SDK, including vision, audio, and multimodal capabilities. Stay tuned!

Resources

aks patching and node pool upgrade azure kubernetes services (aks) explained in plain english

Anand Kumar R — Tue, 29 Mar 2022 17:02:21 +0000

This is part 3 of a multi-part series explaining "everything you need to know about node pools in Azure Kubernetes Services AKS" in plain english using animations. For part 1 click here https://youtu.be/aGT3UtZoiA0 and part 2 please click here - https://youtu.be/45UxnRj11_g

In this video we will talk about:

The different patching and upgrade options for nodepool - Kubernetes Version upgrade and NodeImage upgrade
The upgrade process using cordon and drain methodology
Auto upgrade channels and options for AKS

Commands from the video

Command to list the kubernetes version and the available kubernetes version upgrades on control plane

az aks get-upgrades \
--resource-group ResourceGroupName --name AKSClusterName --output table

Command to list the kubernetes version for all the nodes in your nodepools

az aks nodepool list \

--resource-group ResourceGroupName --cluster-name AKSClusterName \
--query "[].{Name:name,k8version:orchestratorVersion}" --output table

Upgrade kubernetes version on all nodes at once

In order to upgrade all nodes at once - we run the following command, this will upgrade all control plane and worker nodes at once to the desired kubernetes version

az aks upgrade \
--resource-group ResourceGroupName --name AKSClusterName \
--no-wait \
--kubernetes-version KubernetesVersion

Upgrade kubernetes version on control plane alone

If we only want to upgrade the kubernetes version for control plane alone - we run the same command but with the --control-plane-only switch

az aks upgrade \
--resource-group ResourceGroupName --name AKSClusterName \
--control-plane-only --no-wait \
--kubernetes-version KubernetesVersion

Upgrade Kubernetes version on specific node pools

If we need to upgrade the kubernetes version on only specific node pools we can run the following command by specifiying the nodepoolname and the kubernetes version

az aks nodepool upgrade \
--resource-group ResourceGroupName --cluster-name AKSClusterName --name NodePoolName \
--no-wait --kubernetes-version KubernetesVersion

Nodepool image upgrade

Running the following command lists all the current nodeimage versions of the nodepool

az aks nodepool list \
--resource-group ResourceGroupName --cluster-name AKSClusterName \
--query "[].{Name:name,NodeImageVersion:nodeImageVersion}" --output table

the following command to list the available latest nodeimage version for us

az aks nodepool get-upgrades \
--resource-group ResourceGroupName --cluster-name AKSClusterName \
--nodepool-name NodePoolName --output table

Upgrade nodeimage version for specific nodepool

In order to upgrade the nodeimage vefsion for a specific nodepool we run the following command :

az aks nodepool upgrade \
--resource-group myResourceGroup \
--cluster-name myAKSCluster \
--name mynodepool \
--node-image-only

az aks nodepool show \
--resource-group myResourceGroup \
--cluster-name myAKSCluster \
--name mynodepool

Upgrade nodeimage version for all nodepools at once

az aks upgrade \
--resource-group myResourceGroup \
--name myAKSCluster \
--node-image-only

Remember If you don’t run the nodeimage switch remember the whole cluster including the kubernetes version of the control plane is also upgraded.

az aks show \
--resource-group myResourceGroup \
--name myAKSCluster

azure #aks #nodepools #kubernetes #upgrade #cordon #drain #explained #plainenglish

For more simplified video tutorials on Azure and Kubernetes - check out www.azuremonk.com/video

taints, tolerations, nodeselector in aks (azure kubernetes services) explained in plain english

Anand Kumar R — Tue, 29 Mar 2022 17:01:04 +0000

This is part 2 of a multi-part series explaining node pools in Azure Kubernetes Services AKS. For part 1 please click here - https://youtu.be/45UxnRj11_g

In this video we will talk about:

How we can use taints and tolerations to schedule pods in AKS nodes with demo
How we can use NodeSelectors in AKS
Link to Blogpost - https://www.azuremonk.com/blog/kube-scheduler

azure #aks #nodepools #taints #tolerations #nodeselector #kubernetesscheduler #scheduler

For more simplified video tutorials on Azure and Kubernetes - check out www.azuremonk.com/video

azure kubernetes services (aks) node pools explained in plain english

Anand Kumar R — Tue, 29 Mar 2022 16:59:43 +0000

This is part 1 of a multi-part series explaining node pools in Azure Kubernetes Services AKS.

In this video we will talk about:

What is a nodepool? Why do we need them?
Difference between system node pools and user node pools
Walkthrough of how to create a nodepool in AKS

azure #aks #nodepools #systemnodepools #usernodepools #simplified

For more simplified video tutorials on Azure and Kubernetes - check out www.azuremonk.com/video

aks integration with azure ad explained in plain english - azure rbac, kubernetes rbac, kubeconfig

Anand Kumar R — Tue, 16 Nov 2021 21:55:24 +0000

This is the super simplified video animated explanation on everything you ever wanted to know about Azure Active Directory and AKS (Azure Kubernetes Services) - from the basics

What is a kubeconfig file ? Why is it important ?
Azure AD integrated AKS cluster v/s non-Azure AD integrated AKS cluster
Azure Role based access control (RBAC) v/s Kubernetes Role Based Access Control (K8s RBAC)

https://www.azuremonk.com/video

scaling an aks (azure kubernetes services) cluster explained in plain english

Anand Kumar R — Tue, 16 Nov 2021 21:53:44 +0000

This is the super simplified video animated explanation on everything you ever wanted to know about scaling in the context of an AKS cluster (Azure Kubernetes Services). We will cover the following topics:

Manually scale a pod in or our an AKS cluster - how to and demo
Automatically scale pod in or out in an AKS cluster using horizontal pod autoscaler (hpa) - how to and demo.
Manually scale a node in or out an AKS cluster - how to and demo
Automatically scale a node in or out an AKS clusters - the gotchas, how to and demo

https://www.azuremonk.com/video

Kubernetes scheduler visually explained in plain English with a story

Anand Kumar R — Thu, 25 Mar 2021 18:11:51 +0000

In Kubernetes pod is the smallest deployable unit of workload. So the obvious question :

"Where should the pods be deployed?"

Pods always execute inside a Node.

But but.. there are so many Nodes - which one should node should I deploy this pod to ??!

Hello - "Kubernetes Scheduler"

Let's break down how the Kubernetes Scheduler works and the way it chooses a node in plain english with an analogy.

Lets say we have a "social-restaurant" where we have several tables and several seats around each table, lots of customers and a waiter for the hotel. "Social-restaurant" meaning different set of customers can sit around the same table, if there are enough seats and all conditions are met.

Table = Node (VM or a Physical Macine)

Seats = Resources availability on the VM

Waiter = Kube-Scheduler

Customer-Group = Pod

A single customer inside the group = Container

1. Resource requirements and availability

A **Customer-Group* comes into the restaurant and makes a simple request for a table to be seated. The waiter analyses the requirement of the Customer-Group and looks at how many Seats they would need. He then looks through all the available tables, filters the tables that cannot be "scheduled" and assigns (binds) them a table which would meet their Seating requirement.*

This is the basic kind of scheduling - where the kube scheduler constantly watches the API server to see if there are any pods which are unscheduled. Looks through the resource requirement for each of the container inside the pods.

Remember the containers are the ones which have the resource requirement in the spec not the pods themselves.

In the example below we have a CPU and Memory requirement under the container spec for the pod deployment. Requirements are 500 millicpu and an 128 MiB of memory.

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.7.9
    resources:
      requests:
        memory: "128Mi"
        cpu: "500m"

Now let's take a look at one of the nodes (restaurant tables) to ensure they have capacity. The way we would do that is run the following command :

kubectl describe nodes <node-name>

which outputs all the properties of the nodes, but the ones we are interested are the Capacity and Allocatable.

Remember CPU and memory are not the only filter criteria, there are lots more like persistent storage, network port requirements. Detailed list here.

2. Node Selector

Another **Customer-Group* come in to the restaurant with a requirement to be placed in any table which is "blue". The waiter looks through his inventory and finds all the tables which has a label of blue and assigns the Customer-Group to the appropriate table*

In this scenario the pod has a nodeSelector (key-value pair) specified which requests the pod to be deployment to any node which matches the key-value pair.

Here is how the new YAML file will look like:

apiVersion: v1
kind: Pod
metadata:
  name: nginx-blue
spec:
  containers:
  - name: nginx
    image: nginx:1.7.9
  nodeSelector:
    color: blue

In order to query all my nodes to check if we have the label "blue", we run the following command.

kubectl get nodes --show-labels

From the list we can see that "worker-2" has a label of color=blue. Also there are several built-in labels which Kubernetes provides us with too.

Great ! If you now deploy this, the scheduler automatically assigns it to the right node. (worker-2). We can confirm this by running the following command.

kubectl get pod -o wide

Note that if you did not have a node with the appropriate label the deployment would be Pending.

3. Node affinity and anti-affinity

Node affinity and anti-affinity are a lot like node selectors, but it gives you more flexibility by supporting expressive language and soft/hard preference rather than just a hard requirement.

Lets say another **Customer-Group* come in to the restaurant . They have a preference to be placed in any table which is "ocean-view", but its not required. The waiter looks through his inventory and finds all the tables which has a label of "ocean" and assigns the Customer-Group to the appropriate table*

In this example the pod has a nodeAffinity defined which states that we prefer a "node" which matches the key value pair --> view : ocean ( and we do that by the matchExpressions below)

There are two options here :

preferredDuringSchedulingIgnoredDuringExecution : which means that the nodes that match the criteria will be preferred, but not guaranteed when the allocation to the node happens.

IgnoredDuringExecution - If you remove or change the label of the node after the pod is scheduled, the pod won’t be removed. In other words, the affinity selection works only at the time of scheduling the pod but not at execution

requiredDuringSchedulingIgnoredDuringExecution : which means that the nodes that match the criteria will be required when selecting the node. IgnoredDuringExecution is the same as before.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-oceanview
spec:
  containers:
  - name: nginx
    image: nginx:1.7.9
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 1
        preference:
          matchExpressions:
            - key: view
              operator: In
              values:
                - ocean

The operator in this case can also be other values such as In, NotIn, Exists, DoesNotExist, Gt, Lt. NotIn and DoesNotExist will create the opposite effect of nodeAntiAffinity

4. Pod affinity and anti-affinity

Another vegan girl-gang **Customer-Group* come in to the restaurant . They have a requirement not to be placed in any table which contain seats which are already occupied by meat eaters. They are a little more choosy - they also want to be seated in tables which contains seats which are already occupied by boys. In other words they have a non-affinity towards meat-eaters, but have an affinity towards boys.*

Lets take a real world scenario where you have a set of redis-cache and web-server deployments. Here are the conditions:

You want the redis-cache pods deployed as close to the web-servers pods as possible (podAffinity)
You don't want two redis-cache pods in the same node (podAntiAffinity)
You don't want to deploy two web-server pods in the same node (podAntiAffiinity)
You want these rules to hold good for the scope of a node. (topology)

Here is how the redis-cache deployment YAML would look. :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-cache
spec:
  selector:
    matchLabels:
      apptype: redis-cache
  replicas: 3
  template:
    metadata:
      labels:
        apptype: redis-cache
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: apptype
                operator: In
                values:
                - redis-cache
            topologyKey: "kubernetes.io/hostname"
      containers:
      - name: redis-server
        image: redis:3.2-alpine

In the example above:

In the example above you see that the redis-cache label (apptype=redis-cache) is added to every pod which gets deployed as part of this deployment
The podAntiAffinity is described such that no two redis-cache pods are deployed inside the same server. This is defined by the by the built-in topology "kubernetes.io/hostname" which means its a single node. This can also be extended to zones or any other legal-key if required.

Awesome - once you deploy this - here is what you would get :

Now, lets take a look at the web-server deployment YAML file

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-server
spec:
  selector:
    matchLabels:
      apptype: web-server
  replicas: 3
  template:
    metadata:
      labels:
        apptype: web-server
    spec:
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: apptype
                operator: In
                values:
                - web-server
            topologyKey: "kubernetes.io/hostname"
        podAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: apptype
                operator: In
                values:
                - redis-cache
            topologyKey: "kubernetes.io/hostname"
      containers:
      - name: web-app
        image: nginx:1.12-alpine

In the example above:

In the example above you see that the web-server label (apptype=web-server) is added to every pod which gets deployed as part of this deployment
The podAntiAffinity is described such that no two web-server pods are deployed inside the same server. This is defined by the by the built-in topologyKey "kubernetes.io/hostname" which means its a single node. This can also be extended to zones or any other legal-key if required.
The podAffinity is described such that the web-server pods are deployed as close to the redis-cache as possible.

Once you deploy this - we got what we were aiming for - 3 web-servers and 3 redis-cache servers - one copy of each on one node !

5. Taint and Tolerations

This time around the restaurant got one of the tables "tainted" with a peanut spillage disaster. So they have said no new **Customer-Groups* will be scheduled on this table to avoid allergic reactions. So any new Customer-Groups are placed on every other table except this tainted one.*

So far we have been looking at scheduling from a pod perspective. But what if the other way around the node decides not to schedule anymore new pods ? This is where taints come in. Once you taint a node you have two options :

NoSchedule - This means no new pods should be scheduled on this pod once its tainted. *unless they have a toleration
NoExecute - Existing pods will be evicted from the pod once its tainted. *unless they have a toleration (we will talk about tolerations in just a minute)

So how do we taint a node ?

kubectl taint nodes <nodename> mytaintkey=mytaintvalue:NoSchedule

Once we have this set the node is now tainted with the following key value pair (mytaintkey=mytaintvalue). So no new pods can be scheduled.

But what if you want to evict the existing pods from the nodes ?

kubectl taint nodes <nodename> mytaintkey=mytaintvalue:NoExecute

This will evict all pods from the current node and move them to another available node.

But after a while a Customer-Group comes along and says - "Oh that's fine. We have *"toleration"** for peanut allergies. So please proceed and place us in the "tainted" table". The Kube scheduler verifies their toleration and places them in the tainted table*

Now if the pod has a toleration for the taint key value that the node has specified, then this pod will get exempted from the taint and will be placed on the node if necessary.

apiVersion: v1
kind: Pod
metadata:
  name: web-server
spec:
  containers:
  - name: web-app
    image: nginx:1.12-alpine
  tolerations:
  - key: "mytaintkey"
    operator: "Equal"
    value: "mytaintvalue"
    effect: "NoExecute"

credits to Carson Anderson for planting this idea-seed from his awesome Kube-Decon talk

This article originally appeared on www.cloud-monk.com

aks storage - persistent volumes, persistent volume claims and storage classes explained in plain english in less than 5 minutes

Anand Kumar R — Sun, 21 Mar 2021 15:21:18 +0000

This is the simplified visual animated explanation of Persistent Volumes, Persistent Volume Claims and Storage Classes in Azure Kubernetes Services (AKS) with the help of a real world example

In this part we will discuss :

1. What a persistent volume is and why it's important ?
2. What is a persistent volume claim and how to leverage it ? 
3. What is a storage class and how it helps in provisioning persistent volumes dynamically.

If you haven't seen part 1 of the video, please do check it out here --> https://www.youtube.com/watch?v=o7UTiRTfk-M where we cover : Volumes and Volume Mounts Different Kinds of Volumes - Azure Files, Azure Disks, EmptyDir, Secrets and ConfigMaps.

https://www.azuremonk.com/video #aks #azure #azurein5minutes #aksstorage #azuredisks #azurefiles #k8s #aksvolumes #volumetypes #emptydir #secrets #configmaps #persistentvolumes #persistentvolumeclaims #pvc #persistentvolumes #pv #storageclasses https://www.azuremonk.com

https://www.azuremonk.com

AKS (azure kubernetes services) in plain english

aks #azure #azurein5minutes #aksstorage #azuredisks #azurefiles #k8s #aksvolumes #volumetypes #emptydir #secrets #configmaps #persistentvolumes #persistentvolumeclaims #pvc #persistentvolumes #pv #storageclasses

aks storage - volumes explained in plain english in less than 5 minutes

Anand Kumar R — Thu, 04 Feb 2021 11:15:02 +0000

This is the ridiculously simple animated explanation of Azure Storage Options - in less than 5 minutes. In part 1 of the video we will cover :

Volumes and Volume Mounts
Different Kinds of Volumes - Azure Files, Azure Disks, EmptyDir, Secrets and ConfigMaps
Step by step creation of Azure Files and Azure Disks Volumes

In part 2 of the video we will discuss --

Persistent Volume (PV)
Persistent Volume Claims (PVC)
Storage Classes

For more animated Azure videos and simplified Azure content and podcasts please check out https://www.azuremonk.com/video #aks #azure #azurein5minutes #aksstorage #azuredisks #azurefiles #k8s #aksvolumes #volumetypes #emptydir #secrets #configmaps #persistentvolumes #persistentvolumeclaims #pvc #persistentvolumes #pv #storageclasses

https://www.azuremonk.com

AKS (azure kubernetes services) in plain english

aks #azure #azurein5minutes #aksstorage #azuredisks #azurefiles #k8s #aksvolumes #volumetypes #emptydir #secrets #configmaps #persistentvolumes #persistentvolumeclaims #pvc #persistentvolumes #pv #storageclasses

Forem: Anand Kumar R

Stop Coding, Start Managing: A First Look at Google's AntiGravity IDE 🚀

The Killer Feature: Verifiable Artifacts 📹

The Workflow: Asynchronous & Parallel

Human-in-the-Loop Configuration

Final Thoughts

Create Your First Google ADK Agent: A Beginner's Guide

Understanding the Anatomy of an ADK Agent

Prerequisites

Method 1: Create an Agent with the Visual Builder & AI Assist

Method 2: Create an Agent with YAML Configuration

Gemini CLI Custom Slash Commands

What are Slash Commands?

Key Takeaways from My Video

Why You Should Try This

Google's Unified Gen AI SDK: A Hands-on Guide

Google's Unified Gen AI SDK: A Hands-on Guide

Introduction

Getting Started

For Developer API

For Vertex AI (Enterprise)

Generate Streaming Content

Chat Client

Turn 1

Turn 2

Customizing Configuration Parameters

Using System Instructions

Conclusion

Resources

aks patching and node pool upgrade azure kubernetes services (aks) explained in plain english

Commands from the video

Command to list the kubernetes version and the available kubernetes version upgrades on control plane

Command to list the kubernetes version for all the nodes in your nodepools

Upgrade kubernetes version on all nodes at once

Upgrade kubernetes version on control plane alone

Upgrade Kubernetes version on specific node pools

Nodepool image upgrade

Upgrade nodeimage version for specific nodepool

Upgrade nodeimage version for all nodepools at once

azure #aks #nodepools #kubernetes #upgrade #cordon #drain #explained #plainenglish

taints, tolerations, nodeselector in aks (azure kubernetes services) explained in plain english

azure #aks #nodepools #taints #tolerations #nodeselector #kubernetesscheduler #scheduler

azure kubernetes services (aks) node pools explained in plain english

azure #aks #nodepools #systemnodepools #usernodepools #simplified

aks integration with azure ad explained in plain english - azure rbac, kubernetes rbac, kubeconfig

scaling an aks (azure kubernetes services) cluster explained in plain english

Kubernetes scheduler visually explained in plain English with a story

1. Resource requirements and availability

2. Node Selector

3. Node affinity and anti-affinity

4. Pod affinity and anti-affinity

5. Taint and Tolerations

aks storage - persistent volumes, persistent volume claims and storage classes explained in plain english in less than 5 minutes

aks​ #azure​ #azurein5minutes​ #aksstorage​ #azuredisks​ #azurefiles​ #k8s​ #aksvolumes​ #volumetypes​ #emptydir​ #secrets​ #configmaps​ #persistentvolumes​ #persistentvolumeclaims​ #pvc​ #persistentvolumes​ #pv​ #storageclasses

aks storage - volumes explained in plain english in less than 5 minutes

aks​ #azure​ #azurein5minutes​ #aksstorage​ #azuredisks​ #azurefiles​ #k8s​ #aksvolumes​ #volumetypes​ #emptydir​ #secrets​ #configmaps​ #persistentvolumes​ #persistentvolumeclaims​ #pvc​ #persistentvolumes​ #pv​ #storageclasses

aks #azure #azurein5minutes #aksstorage #azuredisks #azurefiles #k8s #aksvolumes #volumetypes #emptydir #secrets #configmaps #persistentvolumes #persistentvolumeclaims #pvc #persistentvolumes #pv #storageclasses

aks #azure #azurein5minutes #aksstorage #azuredisks #azurefiles #k8s #aksvolumes #volumetypes #emptydir #secrets #configmaps #persistentvolumes #persistentvolumeclaims #pvc #persistentvolumes #pv #storageclasses