Forem: Srinivasulu Paranduru

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:

Introduction to GO Programming

Srinivasulu Paranduru — Thu, 20 Nov 2025 00:33:18 +0000

Introduction
Why is it Awesome
Popular Use cases
Tools Built Using Go
Go Software
Enable dependency tracking for your code
Create a module
Call your code from another module
Return and handle an error
Go vs other languages

Introduction :

Go is an open-source programming language developed by Google
It was designed at Google in 2007 by Robert Griesemer,and Ken Thompson, and publicly announced in November 2009.
It is syntactically similar to C, but also has garbage collection, structural typing
It is often referred to as Golang to avoid ambiguity and because of its former domain name, golang.org, but its proper name is Go
the gopher : The Go gopher was created by renowned illustrator Renee French. It has become a beloved mascot for the Go brand. The Gopher is a reminder of the approachability and fun that comes with the Go brand and language.

Why is it Awesome

Focus on simplicity,clarity & scalability
- Inspired by languages like python
- Aims to provide a clean, understandable syntax
High performance & Focus on Concurrency
- Similar to C or C++
- Popular for tasks that benefit from multi-threading
Batteries included
- Go comes with a standard library
- Many core features are built-included
Static typing
- Go is a type-safe language
- Allows you to catch many errors early

Popular Use cases

1.Networking & APIs
2.Microservices
3.CLI Tools

Tools Built Using Go

Docker - Containerization platform
Kubernetes - Container orchestration system
Terraform - Infrastructure as Code tool
Prometheus - Monitoring and alerting toolkit
Hugo - Static site generator
CockroachDB - Distributed SQL database
Traefik - Cloud-native edge router
Etcd - Distributed key-value store
Caddy - Web server
Syncthing - Continuous file synchronization

These applications leverage Go's performance, concurrency, and simplicity.

Go Software

Go to the go website and then click on the download button

Go can be installed in multiple Operating systems and information given below

Its a straight forward installation, just keep click next to complete the installation.

Enable dependency tracking for your code

When your code imports packages contained in other modules, you manage those dependencies through your code's own module.
That module is defined by a go.mod file that tracks the modules that provide those packages. That go.mod file stays with your code, including in your source code repository.
To enable dependency tracking for your code by creating a go.mod file, run the go mod init command, giving it the name of the module your code will be in. The name is the module's module path.
Try the below command in the software folder

go mod init example/hello

_ go: creating new go.mod: module example/hello_

Create a file hello.go file

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Run your code to see the greeting by running the command go run . or go run hello.go > Hello, World!

Create a module

Create a module -- Write a small module with functions you can call from another module.

1.1 Open a command prompt and cd to your home directory.

On Linux or Mac:

cd
On Windows:

cd %HOMEPATH%

1.2 Create a greetings directory for your Go module source code.

For example, from your home directory use the following commands:
```
mkdir greetings
cd greetings
```

1.3 Start your module using the go mod init command

Run the go mod init command, giving it your module path -- here, use example.com/greetings

$ go mod init example.com/greetings
go: creating new go.mod: module example.com/greetings

The go mod init command creates a go.mod file to track your code's dependencies

1.4 create a file greetings.go

1.5 Paste below code into greetings.go file

package greetings

import "fmt"

// Hello returns a greeting for the named person.
func Hello(name string) string {
    // Return a greeting that embeds the name in a message.
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message
}

1.6 Implement a Hello function to return the greeting

1.7 In Go, the := operator is a shortcut for declaring and initializing a variable in one line (Go uses the value on the right to determine the variable's type). Taking the long way, you might have written this as:

var message string
message = fmt.Sprintf("Hi, %v. Welcome!", name)

Call your code from another module

1.Create a hello directory for your source code main folder. This is where you'll write your caller.

After you create the folder and its looks like this

<home>/
 |-- greetings/
 |-- hello/

2.For example, if your command prompt is in the greetings directory, you could use the following commands:

cd ..
mkdir hello
cd hello

3.Enable dependency tracking for the code you're about to write

$ go mod init example.com/hello
go: creating new go.mod: module example.com/hello

4.In your text editor, in the hello directory, create a file in which to write your code and call it hello.go.

Write code to call the Hello function, then print the function's return value
Paste the below code in hello.go file

package main

import (
    "fmt"

    "example.com/greetings"
)

func main() {
    // Get a greeting message and print it.
    message := greetings.Hello("Gladys")
    fmt.Println(message)
}

In the above code declared a main package. In Go, code executed as an application must be in a main package.
Import two packages: example.com/greetings and the fmt package.
Get a greeting by calling the greetings package’s Hello function.

5.Edit the example.com/hello module to use your local example.com/greetings module

To do that, use the go mod edit command to edit the example.com/hello module to redirect Go tools from its module path
From the command prompt in the hello directory, run the following command

$ go mod edit -replace example.com/greetings=../greetings

The command specifies that example.com/greetings should be replaced with ../greetings for the purpose of locating the dependency
go.mod file will small changes with replace command at the bottom

module example.com/hello

go 1.16

replace example.com/greetings => ../greetings

From the command prompt in the hello directory, run the go mod tidy command to synchronize the example.com/hello module's dependencies, adding those required by the code, but not yet tracked in the module.

$ go mod tidy
go: found example.com/greetings in example.com/greetings v0.0.0-00010101000000-000000000000

After running the above code and go.mod looks like below

module example.com/hello

go 1.16

replace example.com/greetings => ../greetings

require example.com/greetings v0.0.0-00010101000000-000000000000

The command found the local code in the greetings directory, then added a require directive to specify that example.com/hello requires example.com/greetings.
You created this dependency when you imported the greetings package in hello.go.
At the command prompt in the hello directory, run your code to confirm that it works.

$ go run .
Hi, Gladys. Welcome!

Return and handle an error

Handling errors is an essential feature of solid code. In this section, you'll add a bit of code to return an error from the greetings module, then handle it in the caller.
Refer Section 4 & 5

1.In greetings/greetings.go, add the code highlighted below

There's no sense sending a greeting back if you don't know who to greet. Return an error to the caller if the name is empty.

package greetings

import (
    "errors"
    "fmt"
)

// Hello returns a greeting for the named person.
func Hello(name string) (string, error) {
    // If no name was given, return an error with a message.
    if name == "" {
        return "", errors.New("empty name")
    }

    // If a name was received, return a value that embeds the name
    // in a greeting message.
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message, nil
}

In this code, you:

Change the function so that it returns two values: a string and an error.
Your caller will check the second value to see if an error occurred.
Import the Go standard library *errors * package so you can use its errors.New function.
Add an if statement to check for an invalid request (an empty string where the name should be) and return an error if the request is invalid. The errors.New function returns an error with your message inside.
Add nil (meaning no error) as a second value in the successful return. That way, the caller can see that the function succeeded.

2.In your hello/hello.go file, handle the error now returned by the Hello function, along with the non-error value

Paste the below code in hello.go

package main

import (
    "fmt"
    "log"

    "example.com/greetings"
)

func main() {
    // Set properties of the predefined Logger, including
    // the log entry prefix and a flag to disable printing
    // the time, source file, and line number.
    log.SetPrefix("greetings: ")
    log.SetFlags(0)

    // Request a greeting message.
    message, err := greetings.Hello("")
    // If an error was returned, print it to the console and
    // exit the program.
    if err != nil {
        log.Fatal(err)
    }

    // If no error was returned, print the returned message
    // to the console.
    fmt.Println(message)
}

Configure the log package
Assign both of the Hello return values, including the error, to variables.
Change the Hello argument from Gladys’s name to an empty string, so you can try out your error-handling code.

3.At the command line in the hello directory, run hello.go to confirm that the code works.

$ go run .
greetings: empty name
exit status 1

Go vs Other languages

Go (Golang) Benefits Compared to Other Languages:

Simplicity:
- Go: Clean, minimal syntax makes code easy to read and maintain.
- Others: Languages like Java or C++ have more complex syntax and features.
Concurrency:
- Go: Native support with goroutines and channels simplifies concurrent programming.
- Others: Python, Ruby, and JavaScript require external libraries or have less efficient concurrency models.
Performance:
- Go: Compiled to machine code, offering fast execution and low memory overhead.
- Others: Interpreted languages (Python, Ruby) are slower; Java requires JVM.
Deployment:
- Go: Produces single static binaries, making deployment straightforward.
- Others: Java needs JVM, Python needs interpreter, C++ may have dependency issues.
Ecosystem:
- Go: Strong in cloud, DevOps, and networking (used in Docker, Kubernetes).
- Others: Java excels in enterprise, Python in data science, C++ in systems programming.
Memory Management:
- Go: Automatic garbage collection with some manual control.
- Others: C/C++ require manual management; Java/Python are fully automatic.
Use Cases:
- Go: Ideal for microservices, cloud infrastructure, CLI tools, and networking.
- Others: Java for enterprise, Python for ML/AI, C++ for performance-critical systems.

Summary: Go stands out for its simplicity, efficient concurrency, fast deployment, and suitability for modern cloud and infrastructure projects.

References:

Conclusion: Introduction to Go Programming.

💬 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 Qlik Replicate & Architecture

Srinivasulu Paranduru — Tue, 18 Nov 2025 11:19:51 +0000

Introduction
Two modes of replication
Qlik Replicate Architecture
Agent Information
Multiple Options in CDC
Supported Environment

Introduction:

Qlik Replicate is a Client-managed log based data replication tool. That access the transaction logs from the source and applies changes to target.

Two modes of replication

Full Load Replication
Change Data Capture(CDC)

Full Load Replication: Takes every thing from source and replicates to target
Change Data Capture : Its runs continuously for the changes in the source and then propagates the changes to the download stream to target in near real time

Examples

Replicate cloud to cloud
Onprem to onprem databases
Onprem to cloud and visa versa

Qlik Replicate Architecture

Qlik Replicate Architecture consists of 4 components

Filter
Transform
File-Channel
In-Memory

You can enhance the data using Filter and Transform
During the transformation from source to destination and some of the data exists In-Memory and Other data may exists in File Channel.
File Channel: File-based directory containing task defintions, metadata and other replication artifacts

Some important points:

Qlik CDC Replication task initially executes a full load sequence
Task continues running, looks for changes made to source and replicating changes to target
Qlik - Web-based Designer and Management console
- Configure the environment
- Create and configure tasks
- Gather environmental statistics
- Debug the environment-
Persistent Store : Qlik Replicate writes information from with in platform environment to external storage

Agent Information:

No software agents on sources and targets for mainstream databases
Replicate data from 100s of source systems with easy configuration
No software upgrades required at each database source or target

Multiple Options in CDC

Transactional CDC
Batch CDC
Data Warehouse Ingest-Merge
Message Encoded CDC

Supported Environment

Conclusion: Introduction to Qlik Replicate & Architecture

💬 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

Forem: Srinivasulu Paranduru

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

Introduction to GO Programming

Table of Contents

Introduction :

Why is it Awesome

Popular Use cases

Tools Built Using Go

Go Software

Enable dependency tracking for your code

Create a module

Call your code from another module

Return and handle an error

Go vs Other languages

Introduction to Qlik Replicate & Architecture

Table of Contents

Introduction:

Two modes of replication

Qlik Replicate Architecture

Agent Information:

Multiple Options in CDC

Supported Environment