## What is a server?

A server is a machine that provides data on request, the application that channels it, and the database which organizes the information.

## Project setup

create a new go project and create a file main.go.

Open the main.go file and import the required packages. We’ll use fmt to print useful data to the terminal and log to print fatal errors in case the web server crashes.

```golang
func main() {
    http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request){
        fmt.Fprintf(w, "Hello!")
    })


    fmt.Printf("Starting server at port 8080\n")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal(err)
    }
}
```

The ListenAndServe method is exported by the http packet we imported during step one. This method allows us to start the web server and specify the port to listen for incoming requests.

We’ll use the HandlerFunc function to add route handlers to the web server. The first argument accepts the path it needs to listen for /hello. Here, you tell the server to listen for any incoming requests for http://localhost:8080/hello. The second argument accepts a function that holds the business logic to correctly respond to the request. By default, this function accepts a ResponseWriter to send a response back and a Request object that provides more information about the request itself. For example, you can access information about the sent headers, which can be useful for authenticating the request.

Start the web server with go run server.go and visit http://localhost:8080/hello. If the server responds with "Hello!"

![Screenshot from 2022-11-02 14-18-07.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1667546293006/USLBrbZj_.png)

visit our next post of the series [lightweight-docker-images-why-and-how?](https://blog.golang.llc/lightweight-docker-images-why-and-how)

## What is AWS Lambda?

AWS Lambda is a serverless computing service provided by Amazon Web Services (AWS) AWS Lambda lets you run code without provisioning or managing servers.

![lambda](https://cdn.hashnode.com/res/hashnode/image/upload/v1670398002254/M52_ErmYF.png)

## How does this work?

You may think, how you make your code work without provisioning a server. Well, you write Lambda functions in one of the languages and runtime supported by AWS lambda. Your code is uploaded to AWS lambda which runs your code only when needed and scales automatically. Not having to provision or manage a server and still having your code run is what makes this a part of the Serverless architecture.

### Are there no servers involved?

No, the concept of serverless means not needed to maintain **your own** server. AWS Lambda service takes care of the servers, the operating systems, the network layer and the rest of the infrastructure, so you just need to focus on writing application code.

### What does "run your code only when needed" mean?

Your lambda function runs the code when it is triggered by an event. Some common ways to trigger your lambda function are :

*   API Gateway
    
*   S3
    
*   DynamoDB Table Streams
    

## Let's code

The best way to learn is to implement.

## What are we building?

We are going to make a simple lambda function in golang. Every developer's favourite: Hello world :)

## Pre-Requisites

*   Basic knowledge of golang
    
*   Basic understanding of handlers
    

## Project setup

From the local machine, create a directory named aws-lambda and change the directory to it.

`mkdir aws-lambda-go && cd aws-lambda-go`

Initialize the Go project with a module file.

`go mod init`

The next part in writing the code in main.go

func hello() (events.APIGatewayProxyResponse, error) { body := "Hello World"

return events.APIGatewayProxyResponse{ StatusCode: 200, Body: body, }, nil }

We have created a handler named hello which returns "Hello World". One thing to note is, this handler returns events.APIGatewayProxyResponse This is because we will be using AWS API Gateway to trigger our lambda and AWS API Gateway expects a response in the mentioned format. It contains our StatusCode which will be 200 for the successful response and our Body which is the `"Hello World"` string.

To add the dependencies use the following commands:

`go get github.com/aws/aws-lambda-go/lambda`

`go get github.com/aws/aws-lambda-go/events`

Our main function calls the handler with Lambda.Start function. Here is how are main.go looks:

package main

import ( "github.com/aws/aws-lambda-go/events" "github.com/aws/aws-lambda-go/lambda" )

func hello() (events.APIGatewayProxyResponse, error) { body := "Hello World"

return events.APIGatewayProxyResponse{ StatusCode: 200, Body: body, }, nil } func main() { lambda.Start(hello) }

### Creating the executable file and zip file

Use the following command to build your executable file

GOOS=linux GOARCH=amd64 CGO\_ENABLED=0 go build -ldflags="-s -w" -o bootstrap cmd/main.go

Now zip the executable file

zip -9 -j bootstrap.zip bootstrap

The next section covers how we deploy our lambda function.

## Serverless Framework

The Serverless Framework is a command-line tool that uses YAML syntax to deploy both your code and cloud infrastructure needed. It supports Node.js, Typescript, Python, Go, Java, and more.

![serverless](https://cdn.hashnode.com/res/hashnode/image/upload/v1670398069000/cBX3rjmex.png)

## Advantages of serverless framework

*   Cost: You pay only for what you use. There is no need to reserve extra space for your services.
    
*   Flexibility: Instances are automatically scaled.
    
*   Accuracy and Speed: Developers can simply deploy their code without having to manage any servers, which helps accelerate delivery cycles and rapidly scale company operations.
    

## Challenges of serverless framework

*   Loss of Control: You’re dependent on a cloud provider for functioning of servers
    
*   Security: If the shared server isn’t configured properly, your application data could be exposed.
    
*   Testing: Developers can run unit tests on function code, but integration tests, which evaluate how frontend and backend components interact, are difficult to perform in a serverless environment.
    
*   Performance Impact: Cold starts are common in serverless environments, adding several seconds of latency to code execution when functions are invoked after a period of inactivity.
    
*   Complexity: If something isn't working as it should, spotting the issue could be difficult. You'll have multiple spaces in which to look.
    

## Serverless Architecture Use Cases

*   Trigger-based tasks: Trigger-based or event-driven tasks are commonly used with serverless framework.
    
*   Building RESTful APIs You can build RESTful APIs using Amazon API Gateway with serverless functions with high scalability.
    
*   Security checks When you spin up a new container, a function can be invoked to scan the instance for misconfigurations or vulnerabilities. Functions can also be used as a more secure option for SSH verification and two-factor authentication.
    
*   Continuous Integration (CI) and Continuous Delivery (CD) Serverless architectures can automate many of the stages in your CI/CD pipelines. For example, code commits can trigger a function to create a build, and pull requests can trigger automated tests.
    

## Install serverless

Set up a new npm package with the following command:

npm init

You will see the following, enter the details as per your wish.

![npm init](https://cdn.hashnode.com/res/hashnode/image/upload/v1670398109384/agIRSoaz7.png)

Install the serverless CLI via NPM:

npm install -g serverless

## Getting started with serverless

The following command will guide you to create a new serverless project

serverless

Moving ahead we will be using the alias "sls" for the serverless commands

Configure your aws credentials

sls config credentials --provider aws --key --secret

( You need to create an AWS IAM user and access key first if you don't have one already )

### The serverless YAML file

service: aws-lambda-1

provider: name: aws runtime: go1.x region: ap-south-1

functions: blogExample: handler: bootstrap events: - http: method: get path: blogExample cors: origin: "*" headers: "*" package: individually: true artifact: bootstrap.zip

### Let us understand the yaml file

*   Declare the name of your service
    

`service: aws-lambda-1`

*   Configure the provider you are using : Here we are using aws with runtime go1.x as we have written our code in Go.
    

```plaintext
provider:
    name: aws
    runtime: go1.x
    region: ap-south-1
```

*   Declare the functions : We have named our function "blogExample", the handler is the executable file which will run your code when this function is invoked.
    

```plaintext
functions:
    blogExample:
    handler: bootstrap
```

*   Events is what can trigger our function. We will be using an http event, The path to our function will be blogExample. Configure the cors settings. `events: -http: method: get path: blogExample cors: origin: "*" headers: "*"`
    
*   Configuration for your package, here we have a zip file named bootstrap.zip which we will be uploading to our lambda function. The individually ture property enables you to package your functions individually.
    

```plaintext
package:
    individually: true
    artifact: bootstrap.zip
```

*   We named our file bootstrap because if there's a file named bootstrap in your deployment package, Lambda runs that file. If not, Lambda looks for a runtime in the function's layers. If the bootstrap file isn't found or isn't executable, your function returns an error upon invocation. So, using bootstrap file is a safe and general practice.
    

### Deploy your service

sls deploy

*   You should see the following output with your function url:
    

![deploy output](https://cdn.hashnode.com/res/hashnode/image/upload/v1670401001396/oV4zTI03C.png)

*   You can see your function on the AWS Lambda dashboard
    

![dashboard output](https://cdn.hashnode.com/res/hashnode/image/upload/v1670404141632/osiULDURa.png)

We have successfully deployed our lambda function, the serverless deploy takes care creating the required AWS stack.

Hope this blog was helpful in understanding AWS Lambda and the serverless framework.

![JSON Encoder.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1669896047252/MyY91j1XT.png)

## Introduction

Encoding and decoding are used in many forms of communications, including computing, data communications, programming, digital electronics and human communications. These two processes involve changing the format of content for optimal transmission or storage.

Encoding is the process of putting a sequence of characters into a serialized format for efficient transmission or storage.

Decoding is the opposite process, the  conversion of an encoded format back into the original sequence of characters.


## Implementation Of Encoding-Decoding 
JSON is a widely used format for data interchange. Golang provides multiple encoding and decoding packages to work with JSON including to and from built-in and custom data types using the ```encoding/json```  package.

#### What is Struct Tag ?

A struct tag is additional metadata information inserted into struct fields. The metadata can be acquired through reflection. Struct tags usually provide instructions on how a struct field is encoded to or decoded from a format. Json object is a collection of key-value pairs. While encoding, struct tags acts as key for a particular value of their corresponding field in structure. Without, struct tags encoder would not be able to map struct values to their corresponding keys and generates an error.

Struct tags are used in popular packages including:

1. encoding/json
2. encoding/xml
3. gopkg.in/mgo.v2/bson
4. gorm.io/gorm
5. github.com/gocarina/gocsv
6. gopkg.in/yaml.v2

The example uses struct tags to configure how JSON data is encoded.

    type User struct {
        Id         int    `json:"id"`
        Name       string `json:"name"`
    }
With `json:"id"` struct tag, we encode the ```Id``` field in lowercase.

### Implementation of ENCODING method


Let us define Response structure.

    type UserResponse struct {
        ID    int    `json:"id"`
        Name  string `json:"name"`
        Email string `json:"email"`
    }

In the request handler, ```json.NewEncoder``` create an encoder with ResponseWriter, and call the ```encode``` method. ```NewEncoder``` returns an encoder object that is used to encode the data into JSON. The purpose of encoding is to transform data so that it can be properly (and safely) consumed by a different type of system, e.g. binary data being sent over email, or viewing special characters on a web page. The goal is not to keep information secret, but rather to ensure that it's able to be properly consumed.

Syntax ``` func (enc *Encoder) Encode(v interface{}) error```

    func handler(w http.ResponseWriter, r *http.Request) {
        resp := &UserResponse{
            ID:    123,
            Name:  req.Name,
            Email: req.Email,
        }
        err := json.NewEncoder(w).Encode(resp)
        if err != nil {
            http.Error(w, err.Error(), 500)
            return
        }
    }

Output:

    {
        id: 1
        name: ABC
        email: abc@google.com
    }

### Implementation of DECODING method

Input:

    {
        "name":"ABC",
        "email":"abc@google.com"
    }

Define request parameters:  First, you define a structure that represents the request parameters.

    type UserRequest struct {
        Name  string `json:"name"`
        Email string `json:"email"`
    }

In the request handler, ```json.NewDecoder```  create a decoder and call the ```decode``` method with the pointer of the structure created above. It uses ```json/encoding``` library. NewDecoder returns a decoder object that reads from request ```r```.
The decoder introduces its own buffer and may read data from request object 'r' beyond the JSON values requested. Decode reads the next JSON-encoded value from its input and stores it.

    func handler(w http.ResponseWriter, r *http.Request) {
        var req UserRequest
        err := json.NewDecoder(r.Body).Decode(&req)
        if err != nil {
            http.Error(w, err.Error(), 400)
            return
        }
    // process with the request parameters
    }

## Difference between Encoding-Decoding / Encryption-Decryption

We should not get confused between term encoding-decoding and encryption-decryption.

Encoding/decoding is the process of transforming data into such a format that it can be used by a different type of system using publicly available algorithms. The accessible data can be retrieved using decoding. The main purpose is the protection of the integrity of data. The encoded data is less secure. It can easily be decoded.
Example of algorithm: AES, RSA, and Blowfish.

![encodingImg.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1669896084644/xR7xlw_9z.png)

Whereas, Encryption/decryption is the process to encode data securely such that only the authorised user who knows the key or password is able to retrieve the accessible data using decryption. The purpose of encryption/decryption is to transform data to keep it secret from others. The encrypted data is more secure.
Example of algorithm: ASCII, UNICODE, URL encoding, Base64.

![encryptionImg.png](https://cdn.hashnode.com/res/hashnode/image/upload/v1669896132944/w8hycSsaH5.png)

## Conclusion

In this blog, we have explored the process of encoding-decoding, its implementation. Also we have specified the difference between encoding-decoding and encryption-decryption.

## Introduction

Most applications depend on data, whether it comes from a database or an API sends a network request to the API server and returns the data as the response, These round trips take time and can increase your application response time to users. Furthermore, most APIs limit the number of requests they can serve an application within a specific time frame a process known as rate limiting. To get around these problems, you can cache your data so that the application makes a single request to an api, and all the subsequent data rquests will retrieve the data from the cache.Redis, an in-memory database that stores data in the server memory, is a popular tool to cache data.

## What is Caching?

A cache is a memory buffer used to temporarily store frequently accessed data. It improves performance since data does not have to be retrieved again from the original source. Caching is actually a concept that has been applied in various areas of the computer/networking industry for quite some time, so there are different ways of implementing cache depending upon the use case. For example very common cache, used on almost all PCs, is the web browser cache for storing requested objects so that the same data doesn't need to be retrieved multiple times.

## Redis

Redis is an open source , in-memory data structure store used as a database, cache, message broker, and streaming engine. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperlogs, geospatial indexes and streams. Redis has a built-in replication Lua scripting, LRU eviction , transactions and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis cluster.

## Redis setup

For locally running the redis server we can docker-compose with following configuration

```plaintext
version: '3.3'
services:
  cache:
    image: redis:6.2-alpine
    restart: always
    ports:
      - '6380:6379'
```

For using the redis in our golang code we need to initiate the redis client in the following way: package providers

```plaintext
package providers

import (
	"context"
	"github.com/go-redis/redis/v8"
	"log"
	"time"
)

type CacheClient struct {
	Client *redis.Client
	Ctx    context.Context
}

func NewCacheClient() CacheProvider {

	client := redis.NewClient(&redis.Options{
		Addr: "localhost:6380",
	})

	err := client.Ping(context.Background()).Err()
	if err != nil {
		log.Fatalf("unable to connect redis server %v", err)
	}

	return &CacheClient{
		Client: client,
		Ctx:    context.Background(),
	}
}

func (c *CacheClient) Get(Key string) string {
	return c.Client.Get(c.Ctx, Key).Val()
}

func (c *CacheClient) Set(key string, value interface{}, expiryTime time.Duration) error {
	return c.Client.Set(c.Ctx, key, value, expiryTime).Err()
}

func (c *CacheClient) Delete(key string) int64 {
	return c.Client.Del(c.Ctx, key).Val()
}
```

In this example we are creating a function(NewCacheClient) to initialise the redis client which is taking the addr parameter and it also have many more parameters which we can also configure but for our use it is not required right now. After creating the redis client we are checking whether it is connected or not using the Ping() function.

A cache has some predefined functionality that is to set and get the data for which we have created an interface and our cache struct is implementing it.

```plaintext
package providers

import "time"

type CacheProvider interface {
Delete(key string) int64
Set(key string, value interface{}, expiryTime time.Duration) error
Get(Key string) string
}
```

Startup Code

```plaintext
package main

import (
"fmt"
"redisSetup/providers"
"time"
)

func main() {
cacheObject := providers.NewCacheClient()

	// setting value in the cache
	err := cacheObject.Set("Name", "Shivam", time.Duration(time.Now().Add(time.Minute*60).Unix()))
	if err != nil {
		return
	}

	// getting value form the cache
	value := cacheObject.Get("Name")
	fmt.Printf("value : %v\n", value)

	// deleting value from cache
	_ = cacheObject.Delete("Name")
	value = cacheObject.Get("Name")
	fmt.Printf("value : %v", value)
}
```

## Advantages of Cache Memory

• Cache is faster and smaller memory which is used for storing the data and are used more frequently from the main memory locations.

• A mapping function is used to correspond the main memory block in the cache memory.

• A primary cache has a less access time comparable to processor register and it is always placed on the processor chip.

• The secondary cache is mention as the level 2 cache and it is also placed in the processor chip.

• It is generally placed between the primary cache and the rest of the memory.

• Cache memory is faster than main memory as a result of two main reasons they are.

• Static Random Access Memory (SRAM) is used in cache memory on the other hand, main memory uses Dynamic Random Access Memory (DRAM).

• Cache memory stores the instructions which may be required by the processor next time; as it helps in recovering the information faster as compared to Random Access Memory (RAM).

• It consumes less access time as compared to main memory.

• It stored program that can be executed within a short period of time.

• It stores data, instructions & information for a limited period.

• The Cache memory is high speed semiconductor memory which can speed up the CPU.

• It makes computer system more speedy.

Basic Server In GoLang

Deploying AWS Lambda in GoLang with Serverless framework

Encoding and Decoding

Caching In GoLang Using Redis