DEV Community: Srinivasulu Paranduru

Google Cloud Storage - Labs - Step by step

Srinivasulu Paranduru — Thu, 14 May 2026 14:16:43 +0000

Cloud Storage - Your Inifinitely Scalable Object Store

Creating an Cloud Storage Bucket
Access control lists
Enable lifecycle management
Enable versioning

Creating an Cloud Storage Bucket

1.In the Google Cloud console, in the Navigation menu (Navigation menu icon), click Cloud Storage > Buckets.

Note :A bucket must have a globally unique name.

2.Create
3.Specify the following, and leave the remaining settings as their defaults:

Name : Enter a globally unique name
Location type : Region
Region : Select Region
Enforce public access prevention on this bucket : unchecked
Access control : Fine-grained 4.Make a note of the bucket name. It will be used later in this lab and referred to as [BUCKET_NAME]. 5.Click Create.

Download a sample file using CURL and make two copies

1.In the Cloud console, click Activate Cloud Shell
2.If prompted, click Continue.
3.Store [BUCKET_NAME] in an environment variable:

export BUCKET_NAME=<enter bucket name here>

4.Verify it with echo:

echo $BUCKET_NAME

5.Run the following command to download a sample file (this sample file is a publicly available Hadoop documentation HTML file):


curl \
https://hadoop.apache.org/docs/current/\
hadoop-project-dist/hadoop-common/\
ClusterSetup.html > setup.html

6.To make copies of the file, run the following commands:


cp setup.html setup2.html
cp setup.html setup3.html

Access control lists

Task 2: Access control lists (ACLs)

You set access control lists to restrict access to the file that you copy to the Cloud Storage bucket.

Copy the file to the bucket and configure the access control list

1.Run the following command to copy the first file to the bucket:

gcloud storage cp setup.html gs://$BUCKET_NAME/

2.To get the default access list that's been assigned to setup.html, run the following command:

gsutil acl get gs://$BUCKET_NAME/setup.html  > acl.txt
cat acl.txt

3.To set the access list to private and verify the results, run the following commands:


gsutil acl set private gs://$BUCKET_NAME/setup.html
gsutil acl get gs://$BUCKET_NAME/setup.html  > acl2.txt
cat acl2.txt

4.To update the access list to make the file publicly readable, run the following commands:


gsutil acl ch -u AllUsers:R gs://$BUCKET_NAME/setup.html
gsutil acl get gs://$BUCKET_NAME/setup.html  > acl3.txt
cat acl3.txt

Enable lifecycle management

Task 3: Enable lifecycle management

In this task, you enable lifecycle management for a Cloud Storage bucket to automate the deletion of objects after a specified period.

View the current lifecycle policy for the bucket

Run the following command to view the current lifecycle policy:


gsutil lifecycle get gs://$BUCKET_NAME

Note: There is no lifecycle configuration. You create one in the next steps.

Create a JSON lifecycle policy file

1.To create a file named life.json, run the following command:

nano life.json

2.Paste the following value into the life.json file:


{
  "rule":
  [
    {
      "action": {"type": "Delete"},
      "condition": {"age": 31}
    }
  ]
}

Note: These instructions tell Cloud Storage to delete the object after 31 days.

3.Press Ctrl+O, ENTER to save the file, and then press Ctrl+X to exit nano.

Set the policy and verify

1.To set the policy, run the following command:

gsutil lifecycle set life.json gs://$BUCKET_NAME

2.To verify the policy, run the following command:

gsutil lifecycle get gs://$BUCKET_NAME

Enable versioning

Task 4 : Enable Versioning

In this task, you enable versioning for a Cloud Storage bucket to protect data from accidental deletion or modification.

View the versioning status for the bucket and enable versioning

1.Run the following command to view the current versioning status for the bucket:

gsutil versioning get gs://$BUCKET_NAME

2.To enable versioning, run the following command:

gsutil versioning set on gs://$BUCKET_NAME

3.To verify that versioning was enabled, run the following command:

gsutil versioning get gs://$BUCKET_NAME

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin, github

Introduction to Docker

Srinivasulu Paranduru — Sun, 03 May 2026 00:06:50 +0000

What is Docker?

Docker is an open-source platform designed to automate the deployment, scaling, and management of applications using containerization. Containers allow developers to package an application with all its dependencies—such as libraries, frameworks, and configuration files—into a single, portable unit that can run consistently across different environments.

In simpler terms, Docker ensures that an application runs the same way on a developer’s laptop as it does on a production server.

Why Docker?

Before Docker, developers often faced the “it works on my machine” problem. Applications behaved differently across environments due to variations in operating systems, dependencies, or configurations. Docker solves this by isolating applications in containers that include everything needed to run them.

Key Benefits of Docker

Portability: Containers can run on any system that supports Docker, regardless of the underlying hardware or operating system.
Efficiency: Containers share the host system’s kernel, making them lightweight and faster to start than virtual machines.
Scalability: Docker integrates seamlessly with orchestration tools like Kubernetes, enabling easy scaling of applications.
Consistency: Ensures uniform behavior across development, testing, and production environments.

How Docker Works

Docker uses a client-server architecture:

Docker Client: The command-line tool that communicates with the Docker daemon.
Docker Daemon: The background service that builds, runs, and manages containers.
Docker Images: Read-only templates used to create containers. Each image contains the application code and dependencies.
Docker Containers: Running instances of Docker images that can be started, stopped, or deleted as needed.

When a developer runs a Docker command, the client sends instructions to the daemon, which performs the requested actions.

Common Docker Commands

Command	Description
docker build	Builds an image from a Dockerfile
docker run	Runs a container from an image
docker ps	Lists running containers
docker stop	Stops a running container
docker pull	Downloads an image from Docker Hub
docker push	Uploads an image to Docker Hub

Real-World Use Cases

Microservices Architecture: Docker simplifies the deployment of microservices by isolating each service in its own container.
Continuous Integration/Continuous Deployment (CI/CD): Docker integrates with CI/CD pipelines to automate testing and deployment.
Cloud Migration: Containers make it easier to move applications between cloud providers.
Development Environments: Developers can quickly spin up consistent environments for testing and debugging.

Conclusion
Docker has revolutionized the way applications are built, shipped, and run. By leveraging containerization, it provides developers with a consistent, efficient, and scalable environment that bridges the gap between development and operations. Whether for small projects or enterprise-scale systems, Docker remains a cornerstone of modern DevOps practices.

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in linkedin and dev.to

Wait for more blogs on docker, docker with python+GO+CSharp

Introduction to OpenTofu

Srinivasulu Paranduru — Wed, 08 Apr 2026 08:30:24 +0000

Explore the benefits of Infrastructure as Code (IaC) and dive into OpenTofu, an open source IaC tool forked from Terraform. Learn how OpenTofu works

Introduction to OpenTofu
Key Features
Use Cases
Installation
Tofu Commands
Demo
Free Course

Introduction to OpenTofu

OpenTofu is an open-source infrastructure-as-code (IaC) tool that allows developers and system administrators to define, provision, and manage cloud and on-premises infrastructure using declarative configuration files. It originated as a community-driven fork of Terraform after licensing changes to Terraform’s core, ensuring that the IaC ecosystem remains open and collaborative.

With OpenTofu, you can describe your infrastructure in simple configuration files written in the HashiCorp Configuration Language (HCL) or JSON. These files specify the desired state of your infrastructure—such as servers, networks, databases, and other resources—and OpenTofu automatically figures out how to create, update, or delete resources to match that state.

Key Features:

Open Source Governance: Fully community-led under the Linux Foundation, ensuring transparency and long-term stability.
Terraform Compatibility: Maintains compatibility with existing Terraform configurations and providers, making migration straightforward.
Declarative Configuration: Users define what they want, and OpenTofu determines how to achieve it.
State Management: Keeps track of infrastructure state to ensure consistent deployments and safe updates.
Extensibility: Supports a wide range of providers for cloud platforms like AWS, Azure, and Google Cloud, as well as on-premises systems.

Use Cases:

Automating cloud infrastructure provisioning
Managing multi-cloud environments
Version-controlling infrastructure configurations
Enabling reproducible and consistent deployments
OpenTofu empowers teams to manage infrastructure efficiently, collaboratively, and transparently—without vendor lock-in.

For more information, visit opentofu.

Installation:

Please find the link for software - https://opentofu.org/docs/intro/install/

OpenTofu is available on the winget repository and you can install it by running:

winget install --exact --id=OpenTofu.Tofu

run the command tofu

Verify installation:

tofu -version

Tofu Commands

1.tofu init

Initializes a working directory containing OpenTofu configuration files.
Downloads necessary provider plugins and modules.
Prepares the backend for storing state.
Example: tofu init

2.tofu plan

Creates an execution plan showing what actions OpenTofu will take to reach the desired state.
Compares the current infrastructure with the configuration files.
Does not make any changes — it’s a preview step.
Example: tofu plan

3.tofu apply

Applies the changes required to reach the desired state of the configuration.
Executes the plan generated by tofu plan.
Prompts for confirmation before making changes (use -auto-approve to skip).
Example: tofu apply -auto-approve

4.tofu destroy

Destroys all resources defined in the configuration.
Useful for cleaning up infrastructure.
Prompts for confirmation unless -auto-approve is used.
Example: tofu destroy -auto-approve

5. tofu validate

Validates the configuration files for syntax and internal consistency.
Does not check against actual infrastructure.
Example: tofu validate

6.tofu fmt

Formats configuration files to a canonical style.
Helps maintain consistent formatting across teams.
Example: tofu fmt

7.tofu show

Displays the current state or a saved plan file in a human-readable format.
Example: tofu show

8.tofu output

Reads and displays output values from the state file.
Useful for retrieving values like IP addresses or resource IDs.
Example: tofu output

9.tofu state

Manages the state file directly.
Subcommands include list, show, mv, rm, and pull.
Used for advanced state management.
Example: tofu state list

10.tofu import

Imports existing infrastructure into OpenTofu’s state.
Does not modify the resource, only records it in the state file.
Example: tofu import aws_instance.example i-1234567890abcdef

11.tofu graph

Generates a visual representation of the dependency graph.
Can be used with tools like Graphviz to visualize relationships.
Example: tofu graph | dot -Tpng > graph.png

12.tofu workspace

Manages multiple workspaces (environments) within the same configuration.
Useful for separating dev, staging, and production environments.
Example: tofu workspace new staging

13.tofu providers

Displays information about the providers required by the configuration.
Example: tofu providers

14.tofu version

Displays the current version of OpenTofu.
Example: tofu version

Demo

1.Create a file provider.tf

terraform {
  required_providers {
    aws = {
      source = "hashicorp/aws"
      version = "6.39.0"
    }
  }
}

provider "aws" {
  # Configuration options
 access_key = "Replace_AWS_Access_Key"
 secret_key = "Replace_AWS_Secret_Key"
 region = "Replace_AWS_Region"
}

2.Create a file ec2.tf

data "aws_ami" "ubuntu" {
  most_recent = true

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }
  owners = ["099720109477"] # Canonical
}

resource "aws_instance" "example" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = "t3.micro"

  tags = {
    Name = "HelloWorld"
  }
}

*Run the commands *
1.tofu init : For Initializing the AWS Provider

.terraform folder will be create after running the command tofu init

2.tofu plan : Creates an execution plan showing what actions OpenTofu will take to reach the desired state.

3.tofu apply : Applies the changes required to reach the desired state of the configuration.

4.tofu destroy: Destroy the resources created of any with reference to the configuration files after the user confirmation

Free Course

https://training.linuxfoundation.org/express-learning/getting-started-with-opentofu-lfel1009/

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin, github

Datadog Agent Installation on AWS EC2 (Linux Server) and Sending Logs to Datadog Cloud

Srinivasulu Paranduru — Tue, 24 Mar 2026 12:41:28 +0000

Datadog Agent Installation on AWS EC2 (Linux Server) and Sending Logs to Datadog Cloud

1.Prerequisites

An active Datadog account (https://app.datadoghq.com)
A running AWS EC2 instance (Amazon Linux, Ubuntu, or other Linux distribution)
Root or sudo access to the EC2 instance
Your Datadog API key (found under Integrations → APIs in the Datadog dashboard)

2.Connect to Your EC2 Instance
Use SSH to connect:

ssh -i /path/to/your-key.pem ec2-user@

3.Install the Datadog Agent
For Amazon Linux or RHEL-based systems
DD_API_KEY= DD_SITE="datadoghq.com" bash -c "$(curl -L https://s3.amazonaws.com/dd-agent/scripts/install_script.sh)"

For Ubuntu or Debian-based systems

DD_API_KEY= DD_SITE="datadoghq.com" bash -c "$(curl -L https://s3.amazonaws.com/dd-agent/scripts/install_script.sh)"

4.Enable and Start the Agent

sudo systemctl enable datadog-agent
sudo systemctl start datadog-agent

Check the agent status:

sudo datadog-agent status

5.Enable Log Collection

Edit the Datadog Agent configuration file:

sudo nano /etc/datadog-agent/datadog.yaml

Uncomment and set:

logs_enabled: true

Save and exit, then restart the agent:

sudo systemctl restart datadog-agent

6.Configure Log Sources

To send specific logs (e.g., application logs), create a configuration file under:

/etc/datadog-agent/conf.d/.d/conf.yaml

Example for an Nginx log:

logs:
  - type: file
    path: /var/log/nginx/access.log
    service: nginx
    source: nginx

Restart the agent again:

sudo systemctl restart datadog-agent

7.Verify Logs in Datadog

Go to Logs → Live Tail in the Datadog dashboard.
You should see logs streaming from your EC2 instance.
Use filters like service:nginx or host: to refine results.

8.Optional: Tagging and Metadata

You can add tags to your EC2 instance for better organization:

sudo sh -c 'echo "tags: environment:production,team:devops" >> /etc/datadog-agent/datadog.yaml'
sudo systemctl restart datadog-agent

9.Troubleshooting

Check agent logs:
sudo tail -f /var/log/datadog/agent.log
Ensure outbound traffic to Datadog endpoints is allowed (port 443).
Verify your API key and region are correct.

Final Result:
Your AWS EC2 instance is now sending system metrics and logs to Datadog Cloud for monitoring and analysis.

Datadog Agent Installation on AWS EC2 (Windows Server) and Sending Logs to Datadog Cloud

Srinivasulu Paranduru — Tue, 24 Mar 2026 12:34:13 +0000

Datadog Agent Installation on AWS EC2 (Windows Server) and Sending Logs to Datadog Cloud

1.Prerequisites

A running Windows Server EC2 instance
Administrator access to the instance
A Datadog account and your API key (found in Datadog → Integrations → APIs)
Internet access from the EC2 instance to Datadog endpoints

Download and Install the Datadog Agent

Connect to your EC2 instance via RDP.
Open PowerShell as Administrator.
Run the following command to download and install the Datadog Agent (replace with your actual key):
start-bitstransfer -source https://s3.amazonaws.com/ddagent-windows-stable/datadog-agent-7-latest.amd64.msi -destination C:\datadog-agent.msi
msiexec /i C:\datadog-agent.msi APIKEY= SITE="datadoghq.com" /qn

- If your Datadog site is datadoghq.eu, use SITE="datadoghq.eu" instead.

3.Enable Log Collection

1.Open the Datadog Agent configuration file:
C:\ProgramData\Datadog\datadog.yaml
2.Find and set:
logs_enabled: true
3.Save and close the file.

4.Configure Log Sources
To send specific logs (e.g., application or Windows Event logs):

For Windows Event Logs: Create or edit the file: C:\ProgramData\Datadog\conf.d\win32_event_log.d\conf.yaml Add: init_config:

instances:

name: application event_log: Application
name: system
event_log: System
- For Custom Log Files: Create or edit: C:\ProgramData\Datadog\conf.d\logs.yaml Add: logs:
type: file

path: C:\path\to\your\logfile.log

service: my-service

source: custom

5.Restart the Datadog Agent
Run in PowerShell:

Restart-Service datadogagent

6.Verify Installation

In Datadog, go to Infrastructure → Host Map to confirm your EC2 instance appears.
Go to Logs → Live Tail to check if logs are being received.

(Optional) Tag Your Host You can add tags during installation or later in the config file:

tags:

env:production
role:webserver

Then restart the agent again.

Datadog Documentation Reference:

AWS Lambda in C# with Datadog Integration

Srinivasulu Paranduru — Tue, 24 Mar 2026 11:20:53 +0000

AWS Lambda in C# with Datadog Integration

To integrate Datadog with an AWS Lambda function written in C# (.NET), you can use the Datadog Lambda Extension and Datadog .NET Tracer. This setup allows you to collect metrics, traces, and logs from your Lambda function.

1.Set Up Datadog in AWS

Go to your Datadog account and navigate to Integrations → AWS.
Connect your AWS account using the Datadog AWS integration.
Enable Lambda and CloudWatch Logs permissions for Datadog.

2.Add Datadog Lambda Extension
You can add the Datadog Lambda Extension as a Lambda Layer.

For .NET 6 or .NET 8 runtimes, use the following ARN (replace with your AWS region):

arn:aws:lambda::AWS_Account_ID:layer:Datadog-Extension:latest

Attach this layer to your Lambda function in the AWS Console or via the AWS CLI.

3.Install Datadog .NET Tracer
In your C# project, install the Datadog .NET tracer NuGet package:

dotnet add package Datadog.Trace

4.Instrument Your Code
You can manually instrument your Lambda handler or use automatic instrumentation.

Example:

using System;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
using Datadog.Trace;

[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace MyLambda
{
    public class Function
    {
        public async Task<string> FunctionHandler(string input, ILambdaContext context)
        {
            using (var scope = Tracer.Instance.StartActive("lambda.handler"))
            {
                scope.Span.SetTag("lambda.input", input);
                await Task.Delay(100); // Simulate work
                return $"Processed: {input}";
            }
        }
    }
}

5.Set Environment Variables
In your Lambda configuration, add these environment variables:

Variable	Value
DD_API_KEY	Your Datadog API key
DD_SITE	datadoghq.com (or your region, e.g., datadoghq.eu)
DD_LOGS_ENABLED	true
DD_TRACE_ENABLED	true
DD_ENV	production (or your environment name)
DD_SERVICE	my-lambda-service
DD_VERSION	1.0.0

6.Enable Logging
Ensure your Lambda function sends logs to CloudWatch Logs. Datadog will automatically collect them if the AWS integration is configured.

7.Deploy and Verify
Deploy your Lambda function.
Then, in Datadog:

Go to APM → Services to see traces.
Go to Logs → Explorer to view logs.
Go to Serverless → Functions to monitor Lambda metrics.

Optional: Use Datadog Forwarder If you prefer not to use the extension, you can use the Datadog Forwarder Lambda to forward logs and metrics from CloudWatch to Datadog. You can find setup instructions in Datadog’s documentation: docs.datadoghq.com/serverless/forwarder/

This setup provides full observability—metrics, traces, and logs—for your C# AWS Lambda functions in Datadog.

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin, github

AWS Lambda in Python with Datadog Integration

Srinivasulu Paranduru — Tue, 24 Mar 2026 11:07:00 +0000

Introduction
AWS Lambda is a serverless compute service that allows running code without provisioning or managing servers. It automatically scales applications by running code in response to events. Monitoring and observability are crucial for maintaining performance and reliability, and Datadog provides powerful tools to monitor Lambda functions, collect metrics, and visualize logs.

This guide explains how to integrate AWS Lambda written in Python with Datadog, including setup steps and sample Python code.

Prerequisites

AWS account with permissions to create and manage Lambda functions
Datadog account with API key
AWS CLI and Datadog CLI installed
Python 3.8 or later

Step 1: Create a Python AWS Lambda Function

Open the AWS Management Console.
Navigate to Lambda > Create function.
Choose Author from scratch.
Enter a function name (e.g., lambda-datadog-demo).
Select Python 3.9 as the runtime.
Choose or create an execution role with permissions for CloudWatch Logs.
Click Create function.

Step 2:

Install Datadog Lambda Library
The Datadog Lambda Library enables tracing, metrics, and log forwarding.
Install the library locally:

pip install datadog-lambda pip install ddtrace

Package dependencies into a deployment zip:

mkdir package cd package pip install datadog-lambda -t . pip install ddtrace -t . zip -r ../lambda_function.zip . cd .. zip -g lambda_function.zip lambda_function.py

Step 3: Configure Datadog Integration

In the Datadog dashboard, navigate to Integrations > AWS.
Connect the AWS account by following the setup wizard.
Enable Lambda integration.
Copy the Datadog API key from Integrations > APIs.

Step 4: Add Environment Variables
In the Lambda configuration, add the following environment variables:

Key	Value
DD_API_KEY	your_datadog_api_key
DD_SITE	datadoghq.com (or datadoghq.eu for EU region)
DD_LOGS_ENABLED	true
DD_TRACE_ENABLED	true
DD_FLUSH_TO_LOG	true

Step 5: Instrument the Lambda Function
Create a file named lambda_function.py:

from datadog_lambda.wrapper 
import datadog_lambda_wrapper from datadog_lambda.metric 
import lambda_metric 
from ddtrace import tracer 

@datadog_lambda_wrapper 
def lambda_handler(event, context): # Custom metric   lambda_metric("custom.lambda.invocations", 1, tags=["env:dev", "function:lambda-datadog-demo"]) 

# Example trace with 
tracer.trace("lambda.process_event") as span:  span.set_tag("event.source", event.get("source", "unknown")) result = process_event(event) return {"statusCode": 200, "body": result} 

def process_event(event): # Simulated processing logic 
  message = event.get("message", "Hello from AWS Lambda!") 
  return f"Processed message: {message}"

This code:

Wraps the handler with datadog_lambda_wrapper for automatic instrumentation.
Sends a custom metric to Datadog.
Creates a trace span for event processing.

Step 6: Deploy the Lambda Function
Upload the deployment package:

aws lambda update-function-code \ --function-name lambda-datadog-demo \ --zip-file fileb://lambda_function.zip

Step 7: Enable Log Forwarding

Datadog can collect logs from CloudWatch using the Datadog Forwarder Lambda.

Deploy the Datadog Forwarder from the AWS Serverless Application Repository.
Set the environment variable DD_API_KEY in the forwarder.
Subscribe the forwarder to the CloudWatch log group of the Lambda function.

Step 8: Verify in Datadog
After invoking the Lambda function, open the Datadog dashboard:

Navigate to APM > Traces to view traces.
Go to Metrics Explorer to see custom metrics.

- Check Logs > Live Tail for Lambda logs.

Conclusion
Integrating AWS Lambda with Datadog provides deep visibility into serverless applications. With metrics, traces, and logs unified in one platform, teams can monitor performance, troubleshoot issues, and optimize costs effectively. Using the Datadog Lambda Library in Python simplifies instrumentation and ensures observability from the start.

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin, github

AWS Lambda Integration with DataDog

Srinivasulu Paranduru — Mon, 02 Mar 2026 17:42:14 +0000

Step by step approach for integrating Datadog with AWS Lambda

AWS Lambda metrics :
There are 3 ways to get metrics from AWS Lambda:

You can get Cloudwatch Lambda metrics from the Datadog AWS integration
You can get enhanced metrics by installing Serverless Monitoring for AWS Lambda through the Datadog Lambda Extension.
You can submit custom metrics to Datadog from your Lambda functions.

The Datadog Lambda Extension
The Lambda Extension is installed as an AWS Lambda layer for your functions. Lambda layers are an AWS feature that allow you to separate your function code from its dependencies. A layer is a .zip file archive that contains supplementary code or data, such as library dependencies, custom runtimes, or configuration files.

Once installed, the Lambda Extension collects and sends data from your Lambda function to Datadog, including:

Logs
Traces
Functional-level metrics

The Datadog Lambda Library
The Datadog Lambda Library can help us to to capture distributed traces and enrich your Lambda data.

Implementation of the Lambda Library varies by runtime. For example, for .NET and Java, the Lambda Library is built into the tracer, while Node.js, Python, and Go use separate libraries. You can find detailed instructions for your runtime in the documentation.

Step by Step Approach for AWS Lambda Python integration with data dog

https://dev.to/aws-builders/aws-lambda-in-python-with-datadog-integration-4675

Step by Step Approach for AWS Lambda C#.Net integration with data dog

https://dev.to/srinivasuluparanduru/aws-lambda-in-c-with-datadog-integration-5egb

References :

💬 If you enjoyed reading this blog post and found it informative, please take a moment to share your thoughts by leaving a review and liking it 😀 and follow me in dev.to , linkedin, github

Manage Azure Pipeline agents and pools

Srinivasulu Paranduru — Mon, 02 Feb 2026 23:59:39 +0000

Lab- https://learn.microsoft.com/en-us/training/modules/manage-azure-pipeline-agents-pools/11-configure-agent-pools-understand-pipeline-styles

AZ-400: Implement CI with Azure Pipelines and GitHub Actions

Srinivasulu Paranduru — Mon, 02 Feb 2026 19:07:07 +0000

Explore Azure Pipelines

References :

https://learn.microsoft.com/en-us/training/modules/explore-azure-pipelines/4-understand-key-terms

Google GenAI Leader Certification - Study Plan

Srinivasulu Paranduru — Wed, 21 Jan 2026 13:56:03 +0000

Exam Study Guide
Review Sample Questions
Exam Pattern : Multiple Choice Q & A
Exam Result : Will be displayed Pass/Fail at the end of the exam
Credly Badge : It will take a day or two and you will get an email.
Certification Generation : It will take couple days to generate

Study plan for Google Partners
https://partner.skills.google/paths/1952

SNo	Description	Url
1	Gen AI: Beyond the Chatbot	https://partner.skills.google/paths/1952/course_templates/1268
2	Gen AI: Unlock Foundational Concepts	https://partner.skills.google/paths/1952/course_templates/1265
3	Gen AI: Navigate the Landscape	https://partner.skills.google/paths/1952/course_templates/1261
4	Gen AI Apps: Transform Your Work	https://partner.skills.google/paths/1952/course_templates/1266
5	Gen AI Agents: Transform Your Organization	https://partner.skills.google/paths/1952/course_templates/1267

Study plan for Non Google Partners

Non partners - https://www.skills.google/paths/1951

SNo	Description	Url
1	Gen AI: Beyond the Chatbot	https://www.skills.google/paths/1951/course_templates/1268
2	Gen AI: Unlock Foundational Concepts	https://www.skills.google/paths/1951/course_templates/1265
3	Gen AI: Navigate the Landscape	https://www.skills.google/paths/1951/course_templates/1261
4	Gen AI Apps: Transform Your Work	https://www.skills.google/paths/1951/course_templates/1266
5	Gen AI Agents: Transform Your Organization	https://www.skills.google/paths/1951/course_templates/1267

Getting started with Amazon Q Developer

Srinivasulu Paranduru — Wed, 03 Dec 2025 10:32:53 +0000

Introduction:
Amazon Q Developer is available wherever you work—in popular IDEs, on the command line, in the AWS Management Console, GitLab Duo with Amazon Q, and in the Amazon Q Developer transformation web experience.

Different IDE's where you can start using Amazon Q Developer:

JetBrains
VS Code
Visual Studio
Command Line
Eclipse

Using Amazon Q in VS Code:

Open Visual studio code --> Extensions -> search for Amazon Q and then install

We need to choose one options for Amazon Q to login

I have choosen option1 and popup window like below and you need to Allow Access

Close browser and ready to use from VS Code

Pricing Overview
Amazon Q Developer reimagines the experience across the entire software development lifecycle (SDLC), making it faster and easier to build, secure, manage, and optimize applications on or off of AWS. Amazon Q Developer offers two pricing tiers.

Upgrade to Kiro
The Amazon Q Developer CLI has been rebranded to Kiro.

What does this rebrand mean for you? If you're a user with a personal account: Optionally upgrade the Q CLI and Amazon Q extension in your IDE to Kiro to take advantage of all the updates that will only be available in Kiro going forward
If you're an administrator of Amazon Q Developer Pro subscriptions: Start using the Kiro console to manage your users' subscriptions. The Kiro console is a rebrand of the Amazon Q Developer console, with all the same functionality

References:

DEV Community: Srinivasulu Paranduru

Google Cloud Storage - Labs - Step by step

Table of Contents

Creating an Cloud Storage Bucket

Download a sample file using CURL and make two copies

Access control lists

Enable lifecycle management

Create a JSON lifecycle policy file

Set the policy and verify

Enable versioning

Introduction to Docker

What is Docker?

Why Docker?

Key Benefits of Docker

How Docker Works

Docker uses a client-server architecture:

Wait for more blogs on docker, docker with python+GO+CSharp

Introduction to OpenTofu

Table of Contents

Introduction to OpenTofu

Key Features:

Use Cases:

Installation:

Tofu Commands

Demo

Free Course

Datadog Agent Installation on AWS EC2 (Linux Server) and Sending Logs to Datadog Cloud

Datadog Agent Installation on AWS EC2 (Windows Server) and Sending Logs to Datadog Cloud

- If your Datadog site is datadoghq.eu, use SITE="datadoghq.eu" instead.

AWS Lambda in C# with Datadog Integration

AWS Lambda in Python with Datadog Integration

- Check Logs > Live Tail for Lambda logs.

AWS Lambda Integration with DataDog

Step by step approach for integrating Datadog with AWS Lambda

Manage Azure Pipeline agents and pools

AZ-400: Implement CI with Azure Pipelines and GitHub Actions

Google GenAI Leader Certification - Study Plan

Getting started with Amazon Q Developer