DEV Community: Narravula Muni Sai Teja

[Boost]

Narravula Muni Sai Teja — Wed, 11 Jun 2025 11:48:08 +0000

Narravula Muni Sai Teja

Jun 11 '25

Your Guide to Cracking the EKS Architecture

#kubernetes #eks #containers #aws

Comments

3 min read

Your Guide to Cracking the EKS Architecture

Narravula Muni Sai Teja — Wed, 11 Jun 2025 10:49:35 +0000

EKS looks scary?

No worries — we’ve got the map! Let’s navigate nodes, pods, and clusters the easy way.

Every EKS cluster will have a single endpoint URL used by tools such as kubectl, the main Kubernetes client.

1.Understanding the EKS control plane

When a new cluster is created, a new control plane is created in an AWS-owned VPC in a separate account. There are a minimum of two API servers per control plane, spread across two Availability Zones for resilience, which are then exposed through a public network load balancer (NLB). The etcd servers are spread across three Availability Zones and configured in an
autoscaling group, again for resilience.

The clusters administrators and/or users have no direct access to the cluster’s servers; they can only access the K8s API through the load balancer. The API servers are integrated with the worker nodes running under a different account/VPC owned by the customer by creating Elastic Network Interfaces (ENIs) in two Availability Zones. The kubelet agent running on the worker nodes uses a Route 53 private hosted zone, attached to the worker node VPC, to resolve the IP addresses associated with the ENIs. The following diagram illustrates this architecture:

2.The API Server Component

The API server acts as the communication gateway for both internal cluster components and external clients or services that seek access to the cluster. It is the sole interface through which all agents, users, or services interact with the components within the cluster. The cluster components themselves can only communicate with each other through the API server. It has exclusive access to the cluster database (etcd) which keeps the critical cluster metadata, secrets and other necessary information for cluster management.

3.The ETCD Component

An EKS cluster is a distributed system where several nodes or instances work together to run a workload.2 Distributed systems are susceptible to failures due to their complex interconnections. To recover from such failures, EKS relies on the data stored in the etcd key-value database to maintain the clusters in their desired states. The etcd database holds critical metadata and essential information required to maintain the desired state of EKS clusters.

4.The Controller Manager Component

The controller manager component is the mother of all cluster controllers. It manages the object or cluster controllers. Cluster or object controllers maintain the desired state of their respective cluster objects. They include the node controller which monitors the health of cluster nodes and manages their lifecycle, the replication controller which maintains the desired number of pod replicas in the cluster, the endpoint controller which manages the mapping of services to pods, and the service account and token controllers which manage service accounts and their associated tokens.

Typically, controllers monitor events such as create, update, and delete on resources and trigger appropriate responses to restore objects to their desired state.

5.Scheduler Component

The scheduler is responsible for assigning the most appropriate node to an incoming workload or pod. It relies on decision-making algorithms and a deep understanding of the cluster environment to perform this task. The scheduler takes into account various factors, including resource requirements, hardware and software constraints, policy rules, and affinity or anti-affinity specifications to select a suitable node. Additional inputs in the decision-making process include data locality, potential inter-workload interference, and deadlines

Let's Look at this picture Once:

Did You Know how the end-user Communication works....?

End users can interact with pods or applications running on the data plane through a load balancer deployed not in the control plane but in the data plane as shown in below image. This interaction does not require a NAT or Internet gateway, regardless of the cluster configuration option.

In this setup, the load balancer acts as the frontend, handling traffic from end users, while the worker nodes serve as the backend. The load balancer routes traffic from the end users to the appropriate application pods running on the worker nodes, ensuring efficient communication without exposing the internal network.

Heyyyyy....!

Congrats! You just turned EKS from “What the Kube?” to “I got this.”
Keep building, keep exploring, and remember: every pod counts!
Until next time — happy kubectl-ing!

Let's Connect with me in LinkedIn: https://www.linkedin.com/in/munisaiteja-narravula/

Serverless-AI-Chatbot-using-Bedrock Knowledgebase

Narravula Muni Sai Teja — Mon, 28 Apr 2025 12:39:59 +0000

1.Introduction

This project demonstrates how to create a fully serverless chatbot using Amazon Bedrock, Amazon Kendra, and your own documents (PDF, TXT, CSV, etc.). This chatbot uses Retrieval Augmented Generation (RAG) to generate accurate and context-aware responses based on enterprise knowledge bases.

The solution is ideal for use cases such as:
• Technical support automation
• HR knowledge queries
• Compliance document search
• Enterprise data exploration

2.Objective

•Identify the key features of Amazon Bedrock, Amazon Kendra, and AWS serverless services.
•Explain the concept of Retrieval-Augmented Generation (RAG) and how it applies to building an AI-powered chatbot.
•Determine how to use Amazon Bedrock and Amazon Kendra to index and retrieve data from a knowledge base for chatbot interactions.
•Demonstrate how to construct a fully functional generative AI-powered chatbot for a specific use case, integrating Amazon serverless services to efficiently handle application code execution.

3.Architecture

4.Technology Stack

1.Users: End-users of the chatbot
2.Web UI: User interface for chatbot interaction
3.AWS Amplify (React, Vue js): Manages front-end and authentication, specifically using React or Vue.js
4.Amazon API Gateway: Handles API requests
5.AWS Lambda (RAG/KB/LLM Functions): Executes serverless functions for Retrieval-Augmented Generation, Knowledge Base operations, and LLM interactions
6.Amazon Bedrock: Provides access to AI models and services
7.Large Language Models (Claude 3, Mistral, Llama etc.): AI models powering responses
8.Knowledge Bases: Stores structured information
9.Amazon S3: Object storage for documents and data
10.Documents (pdf, csv, txt etc.): Various file types for ingestion
11.Amazon OpenSearch: Vector database and search engine for efficient similarity search
12.Amazon Cognito: User authentication and authorization.

5.Implementation (Step-by-Step)

5.1 IAM Permissions and Roles

1.Kendra Role

Open IAM Console Go to IAM Roles in AWS Console → Click Create role.
Choose Trusted Entity •Trusted entity type: AWS Service •Use case: Choose Kendra •Click Next 3.Name and Create the Role •Role name: AmazonKendra-us-east-2-chatbot-2025 (or your naming convention) •Click Create role
Add Permissions Policy •Click Create policy → Choose JSON tab •Paste the following policy:

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowS3ReadAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::your-s3-bucket-name",
"arn:aws:s3:::your-s3-bucket-name/*"
]
},
{
"Sid": "AllowCloudWatchLogging",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "*"
}
]
}

•Click Next, then Create policy

Name and Create the Role •Role name: AmazonKendra-us-east-2-chatbot-2025 (or your naming convention) •Click Create role

2. Lambda Execution Role

•Go to IAM > Roles > Create role
•Choose AWS Service > Lambda > Click Next
•Attach these 7 AWS managed policies:
AmazonBedrockFullAccess
AmazonCognitoPowerUser
AmazonKendraFullAccess
AmazonS3ReadOnlyAccess
AWSLambdaBasicExecutionRole
AmazonAPIGatewayInvokeFullAccess
AmazonSSMReadOnlyAccess
•Click Next → (Skip tags) → Name it Chatbot_Lambda_Role_2025 → Click Create role

3. Knowledgebase_bedrock_role

Go to IAM > Roles > Create role
Choose AWS service > Bedrock (or use Custom Trust Policy if prompted for specific service access) → Click Next
On Add permissions page, skip adding managed policies → Click Next
Set Role name as Knowledgebase_bedrock_role → Click Create role
Once created, go to the role → Click Add inline policy
Go to JSON tab and paste the inline policy (see below)
Click Review policy
Name it knowledgebase_inline_policy → Click Create policy

5.2 Create an S3 Bucket for Knowledge Documents

Go to Amazon S3 in the AWS Console.
Click on “Create bucket”.
Enter a unique bucket name (Chatbot-docs-bucket000).
Choose the Region where your services are hosted.
Uncheck "Block all public access" (only if private access via roles is set properly).
Leave other settings as default and click Create bucket.
After the bucket is created:
Upload 1-2 sample files (e.g., .pdf, .csv, .txt) under a folder (e.g., /knowledge/).
Note the full S3 URI.

5.3 Amazon Kendra Setup for GenAI Chatbot

Step 1: Create an Amazon Kendra Index

1.Navigate to the Amazon Kendra Console:

Open the Amazon Kendra Console.
Select Create index to begin the index creation process.
2.Configure the Index:
Index Name: Provide a unique name for your index, such as GenAI-Chatbot-Index.
Description: Optionally add a description for the index (e.g., "Index for enterprise knowledge base for chatbot").
Language: Select the language for the content (e.g., English).
IAM Role: Choose an existing IAM role with necessary permissions.
3.Review & Create:
Review the details and click Create to finalize the index setup.

Step 2: Configure Data Sources for Kendra Index

1.Choose a Data Source:

After the index is created, select Data sources from the Kendra console.
Click Add data source to start the configuration for content ingestion.

2.Select the Content Source:

Choose S3 as the data source for your documents (PDFs, CSVs, TXT files).
Enter a name for the data source (e.g., S3-Documents).

3.Configure S3 Data Source:

S3 Bucket: Provide the S3 bucket where your documents are stored.
Access Role: Specify an IAM role with permissions to read from the S3 bucket.
Document Metadata: Configure metadata fields if necessary (e.g., author, document type).

3.Create Data Source:

Review the settings and click Create to complete the data source setup.
Start Sync.

5.4 Create a Bedrock Knowledge Base

1.Go to Bedrock Console:https://console.aws.amazon.com/bedrock/home
2.Navigate:In the left panel, click "Knowledge bases" → "Create knowledge base"

3.Basic Info:

Name: Hello-chatbot
Description: (Optional) GenAI chatbot with RAG using Bedrock
4.IAM Permissions:
Choose "Create and use a new IAM role"
(Or use existing role like Knowledgebase_bedrock_role)

5.Embeddings Model:

Provider: Amazon
Model: Titan Text Embeddings V2

6.Vector Store:

Choose Amazon OpenSearch Serverless (recommended)

7.Set Up Data Source:

Select your bucket name or Amazon Kendra as a data source for knowledge base.

8.Review & Create:

Review all settings
Click "Create knowledge base"

After Successfully creation you need to sync the knowledge base to the data source for chatbot to give the answers for your questions as per you documents.

Let’s check the Results BOOM……..!

Serverless OpenSearch vector Database for Knowledge Base

It is Created Automatically During the creation on Bedrock Knowledge Base.

It's Very Simple To create AI Chatbot Using Amazon Bedrock with Your Natural data.

4.5 AWS Lambda Function for Chatbot Logic

Go to Lambda Console.
Click Create function.
Choose Author from scratch:
Name the lambda function.
Runtime: Python 3.12 or Node.js (your choice)
Assign a role with Kendra & Bedrock access.

5.6 Create API with Amazon API Gateway

Go to API Gateway Console.
Click Create API → Choose HTTP API.
Add a route:

Method: POST
Path: /ask

Integration:

Choose Lambda function (select your chatbot Lambda).

Enable CORS.

Click Next → Review → Click Create.
Copy the Invoke URL (you’ll use it in frontend).

5.7 Cognito User Pools

Create a User Pool: Go to the Amazon Cognito Console, select Create a User Pool, name it (e.g., webapp-userpool), and configure email as a required attribute with email verification enabled.
Add a User: Under the Users and groups tab, click Create user, enter the user’s email, and set Email verified to Yes.
Confirm: Check the Users tab, ensuring the user appears with Email verified set to Yes.

5.8 Deploy Web UI Using AWS Amplify

Go to AWS Amplify Console.
Click Get Started under Host a Web App.
Connect your frontend GitHub repo,s3 or Zipfolder.

For Zip Folder select Deploy Without git Option.

Choose branch → Amplify auto-detects framework.
Configure build settings (default works for React).
Deploy.
App is now live → Connect it to API Gateway & Cognito.

Rock On Yeahh…….!

Conclusion

This serverless chatbot architecture offers a powerful and flexible approach to enterprise-level conversational search using Retrieval-Augmented Generation (RAG). With scalable cloud-native services, you can build intelligent assistants that understand and retrieve contextually accurate responses, powered by your own documents.

*Use this project to: *

Enhance customer and employee support
Provide intelligent knowledge base interfaces
Automate internal data discovery workflows

GitHub Repo Link:

https://github.com/Narravula070/Serverless-AI-Chatbot-using-Bedrock.git

Follow Me on LinkedIn:

https://www.linkedin.com/in/munisaiteja-narravula/

Happy Learning and Deep Dive into AI Technologies for Future ....!

First Lambda Function

Narravula Muni Sai Teja — Thu, 24 Apr 2025 10:00:10 +0000

AWS Lambda is a serverless compute service that lets you run code without provisioning or managing servers. You just upload your function, and it automatically runs in response to events.

Run code without servers — just write your function, upload it, and it runs automatically in response to events (like API calls, file uploads, DB changes).

Key Uses:

API backends
File/image processing
Automation tasks
Real-time data handling

You only pay when it runs — no need to manage servers.

It's Time to Create Your First Lambda Function

In the AWS Management Console search bar, enter Lambda, and click the Lambda result under Services: You will see a page load that welcomes you to the AWS Lambda service:

Click Create a function to start creating your first AWS Lambda function.

3.Select Author from scratch and enter the basic details

Name: Hello Lambda
Runtime: Node.js 22.x
Permissions: Click Change default execution role
Execution Role: Select Use an existing role
Existing role: Select the role beginning with Your lambda role

Note: Create role with Lambda Full access

Click Create function.
Scroll down to the Code source section and replace the contents of the index.mjs with the following code:

console.log("Loading function");
export const handler = async (event, context) => {
  console.log(JSON.stringify(event, null, 2));
  const message = JSON.parse(event.Records[0].Sns.Message);
  if (message.cook_secs < message.req_secs) {
    const messageText = message.pre
      ? `User ended ${message.pre} preset early`
      : "Hello RCB.. Ee Sala Cup Namdu";
    context.succeed(messageText);
  }
  context.succeed();
};

Click Deploy at the top to save and deploy the Lambda function.

Let's test the Lambda Code:
The code you used in the previous lab step reads an incoming SNS message and parses the JSON body to be analyzed (line 4), then checks if the microwave was stopped before the requested number of seconds (line 5), and finally if a preset was used or not (lines 6-8)

To begin creating a test event, click Test and Create new test event.
In the form, enter the following values: Event name: Event JSON: Enter the following JSON into the event editor at the bottom of the form:

{
  "Records": [
    {
      "EventSource": "aws:sns",
      "EventVersion": "1.0",
      "EventSubscriptionArn": "arn:aws:sns:EXAMPLE",
      "Sns": {
        "Type": "Notification",
        "MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
        "TopicArn": "arn:aws:sns:EXAMPLE",
        "Subject": "TestInvoke",
        "Message": "{\"gid\":\"foo1234\",\"cook_secs\":90,\"req_secs\":150,\"cmds\":[2,3,0,\"start\"]}",
        "Timestamp": "1970-01-01T00:00:00.000Z",
        "SignatureVersion": "1",
        "Signature": "EXAMPLE",
        "SigningCertUrl": "EXAMPLE",
        "UnsubscribeUrl": "EXAMPLE",
        "MessageAttributes": {
          "Test": {
            "Type": "String",
            "Value": "TestString"
          },
          "TestBinary": {
            "Type": "Binary",
            "Value": "TestBinary"
          }
        }
      }
    }
  ]
}

Click on save To save the test.

Click the test button to test the Lambda Function.

Boom..... You successfully Completed the creation and testing your first Lambda Function.

Follow me on LinkedIn:
https://www.linkedin.com/in/munisaiteja-narravula/

Learn the Serverless Concepts to reduce costs in Your Account.