{"componentChunkName":"component---src-templates-tag-js","path":"/tags/go/","result":{"data":{"site":{"siteMetadata":{"title":"LoginRadius Blog"}},"allMarkdownRemark":{"totalCount":9,"edges":[{"node":{"fields":{"slug":"/engineering/why-we-rebuilt-loginradius-dot-net-core-apis-with-go/"},"html":"

Introduction

\n

Currently, the LoginRadius Identity Platform processes more than 100K requests per second. As our developer and enterprise customers grow, we should be able to scale our APIs to handle staggering loads of requests per second. It won’t be surprising if our APIs have to serve a million requests per second in the future.

\n

Generally, we add more instances, CPU, or memory for supporting high request volumes. However, it has been burdening our infrastructure budget and maintenance.

\n

So, we’re focused on reducing the cost of compute capacity by improving efficiency. In this engineering update, we share our experience with a highly effective, low-risk, large-scale performance and cost optimization with Go.

\n

LoginRadius production environment consists of 30+ microservices backed by a cloud-native infrastructure. Most of these services are written in .NET and Node.js. In Q1 2021, we explored the possibilities of improving the performance of our services and optimizing costs.

\n

How LoginRadius Has Been Handling High RPS Throughput?

\n

LoginRadius tech stack consists of 30+ microservices. We have different microservices for each business service like Authentication, Web SSO, Federated SSO, etc.

\n\n

1) Architecture

\n

Core Applications: Multiple microservices instances for Authentication, Account API, Analytics API, Risk-based Authentication, Backend Jobs, Integrations, and much more,

\n

Data Storage: MongoDB, Elasticsearch, Redis, and PostgreSQL clusters are used to store a range of datasets for various applications and functionalities.

\n

Queues: Amazon Kinesis Data Streams, Amazon Simple Notification Service (SNS), Amazon Simple Queue Service (SQS), and Azure Queue Storage.

\n

Other Services: Services for rate-limiting, bcrypt clusters, feature flags, and more.

\n

Routing: AWS load balancers (ALB, NLB, and ELB from AWS) and some nodes running NGINX as a proxy.

\n

2) Availability

\n

We've been utilizing a multi-cloud and multi-region architecture for years based on our and our customers’ data and privacy compliance requirements. However, as our usage (and load) grew with maintenance costs, we relied more on AWS resources.

\n\n

This is the basic architecture of the environment in the US:

\n

\n \n \n

\n

The above diagram shows two cloud regions — US East and US West.

\n

When requests come:

\n\n

So, how do we maintain high availability?

\n

Every availability zone has operating instances of all services (including databases). If one availability zone is down, we still have two availability zones.

\n

3) Scaling

\n

We are using a two-pronged scaling approach as scaling based on resource utilization (CPU & Memory) alone is not practical.

\n
    \n
  1. Traffic-based scaling
    2. \n
  2. Based on CPU & Memory utilization
    3. \n
\n

Why Scaling Was Challenging?

\n

Once, our multi-tenant application received a sudden spike in API requests — from thousands of requests to millions. Usually, adding new infrastructure to the existing pool takes around 60 seconds. And application deployment and start-up time were about 90 seconds. Plus, considering other possible delays in scaling, we can lose about 5 minutes for scaling up.

\n

Further, adding the time to gather metrics and make the scaling decision, the total delay can be ~6 minutes. This process can impact all multi-tenant customers' critical applications because user authentication and authorization are essential.

\n

We keep Scaling Buffers to support this kind of scenario.

\n
\n

Scaling Buffers: During the Scale-up Time, the Scaling Buffer is the service's highest predicted traffic spike. Depending on the scaling strategy, we store several types of the buffer.

\n
\n

Usually, we set a one million requests concurrency buffer. And based on the traffic pattern, our scaling automation triggers the scaling.

\n

Why Our Platform Performance Was Good, But Not Great?

\n

Our Platform performance is good. We can quickly handle millions of requests, and our application platform was scalable but not great. Minding the kind of growth we’re expecting, we wanted to improve and prepare our platform for the future.

\n

Challenges in the Existing Platform

\n

1) Startup Time

\n

No. of requests can fluctuate within a few seconds if not minutes or hours, especially with specific events such as holiday shopping, promotional events, Black Friday, etc. So, in the event of traffic spikes, application startup time plays a significant role in scaling.

\n

Our application startup time was around 90 seconds, so whenever scaling was happening due to high traffic, scaling took more time. That's why we needed to improve the application startup time.

\n

2) Cost

\n

We used hundreds of AWS c5.2xlarge instances in a production environment to handle daily traffic. During certain events such as holiday shopping and Black Friday, we doubled our infrastructure according to expected traffic with a 20~30% buffer. We kept a high buffer because scaling took time with the existing .NET Core services. As a result, infrastructure cost was burdening as we were inefficiently deploying cloud infrastructure.

\n

3) Lack of Flexibility and Customization

\n

We designed our Identity Platform a few years ago. Since then, the technology landscape has dramatically improved and optimized in recent years.

\n

Also, current technology platforms available to build and support our product (Identity Platform) are limited. So, it is crucial to align functionality with proper technology capabilities.

\n

We were facing challenges in customization. It was inflexible and limiting to deliver the required outcomes in more complex situations and use cases.

\n

The Road to Lightning Performance, Thanks to Go

\n

Why Go?

\n

We did a lot of research to choose the appropriate programming language for our application. We needed a language that would be simple to understand and learn, easy to maintain, and has high concurrency. Our research ended with Go due to its amazing qualities.

\n

Let's take a closer look. Why choose Go? What makes Go such an excellent development language? What distinguishes it from the competition?

\n

Let's get to the bottom of this by looking at what makes Go special.

\n

Go — Background

\n

Go is an open-source programming language developed by Google's Rob Pike, Robert Griesemer, and Ken Thompson. It was initially released in 2009. It has several enhancements and additions based on the C syntax to properly control memory use, manage objects, and enable static or strict typing along with concurrency.

\n

1) Concurrency

\n

Concurrent code can be executed in parallel by separate computer cores or in sequence. Most programming languages lack concurrent execution when working with multiple threads. They often slow down programming, compiling, and execution.

\n

Go works with goroutines that are lightweight, low-cost threads. And Go channels allow goroutines to communicate with one another.

\n

Sequential Processes Communication: They are very similar to threads in Java but lightweight, and the cost of creating them is meager.

\n

2) Performance

\n

Go's core value is simplicity: it builds quickly, runs quickly, and is simple to learn. To help speed things up, there are no classes or type inheritance. This makes it easier to build a market-ready product quickly. Furthermore, its simplicity allows for quick and simple maintenance.

\n

3) Standard Library

\n

Go has an excellent standard library that includes a large number of built-in essential type functions and packages that are both practical and straightforward to use: I/O, encoding and decoding, manipulating raw bytes, network utility functions, parsing, debugging, and a lot more are all made simple by particular packages. Testing support is also included in the standard library, so no other dependencies are required.

\n

4) Easy to Learn

\n

Go has a simpler syntax than other languages and is simple to learn. The syntax of Go is somewhat similar to the C language. Developers can begin with Go in a couple of hours, but they need to spend time understanding best coding practices, especially understanding goroutines for concurrency.

\n

Benchmarking API Performance Gains

\n

We run benchmarks on our API so that the performance insights help us make decisions about the tech stack. It will paint a clearer picture of where we stand compared to our existing tech stack and what areas need improvement or immediate attention.

\n

We did multiple stress tests on our high usage APIs built separately with .NET Core(Old) and Go (new).

\n

We are using Kubernetes to deploy and manage our microservices and application infrastructure and deploy our application microservices across multiple Pods.

\n

Stress Test Scenario

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Test ItemValue
Instance Typec5.2xlarge on AWS
No. of Instances20
Reverse ProxyNGINX
Concurrent Requests20K per second
Duration5 minutes
Stress Test ToolGatling
\n

We deployed both applications in the same infrastructure and did the same stress test.\nGolang application has performed much better.

\n

Existing Application Matrix — .NET Core

\n
\n \n \n \"Requests\n \n
Graph - 1(a): Requests and Responses per Second (.NET Core)
\n
\n \n
\n \n \n \"API\n \n
Graph -1(b): API Response Time (.NET Core)
\n
\n
\n \n \n \"Overall\n \n
Graph - 1(c): Overall Matrix (.NET Core)
\n
\n

You can see some errors in Graph - 1(a) after ramping up to 15K users. Also, response time is increasing, as seen in Graph - 1(b).

\n

The application can recover after a couple of seconds, and after that, the application cannot respond. Application scaling is taking time. And existing infra cannot handle this spike, so the application crashes after 18K RPS.

\n

New Application Matrix — Go

\n

We did the same stress test with the new Go application. It is easily able to handle this kind of concurrency without any issue.

\n
\n \n \n \"Requests\n \n
Graph - 2(a): Requests and Responses per Second (Go)
\n
\n \n
\n \n \n \"Overall\n \n
Graph - 2(c): Overall Matrix (Go)
\n
\n

The Go application can easily handle 20K ramp-up requests per second without any issue, as shown in Graph -2(a).

\n

You can see in Graph - 2(b) what the response time was after 2 min 47 sec for a couple of seconds. The Go application was scaling during that time. It is scaling quickly, so it is not impacting API request performance, and, also, the application can recover response API time as expected.

\n

Conclusion

\n

In this article, you have learned how we have achieved better API performance by rebuilding them in Go, which were previously built in .NET Core. And you have understood our approach to this transition and how it increased the API performance of the LoginRadius Identity Platform.

\n

Leverage LoginRadius Identity Platform to build authentication functionality for your web and mobile apps. Sign up for a free LoginRadius account here

\n","frontmatter":{"date":"June 06, 2022","updated_date":null,"title":"Why We Re-engineered LoginRadius APIs with Go?","tags":["Go","API",".NET","LoginRadius"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/b63787a6ecfda78c022020fe03233557/ee604/high-performance-identity-apis.png","srcSet":"/static/b63787a6ecfda78c022020fe03233557/69585/high-performance-identity-apis.png 200w,\n/static/b63787a6ecfda78c022020fe03233557/497c6/high-performance-identity-apis.png 400w,\n/static/b63787a6ecfda78c022020fe03233557/ee604/high-performance-identity-apis.png 800w,\n/static/b63787a6ecfda78c022020fe03233557/f3583/high-performance-identity-apis.png 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Vijay Singh Shekhawat","github":"code-vj","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/build-push-docker-images-golang/"},"html":"

Let's walk through how to build and push Docker images programmatically using Go. To do this, we need to talk to the Docker daemon via the Docker Engine API. This is similar to how the Docker CLI works, but instead of entering commands through a CLI, we'll be writing code with Docker's Go SDK.

\n

At the time of writing, the official Docker Go SDK docs provide great examples of running basic Docker commands with Go. However, it's missing examples on building and pushing Docker images, so we'll go over those in this blog.

\n

Before we begin, this blog assumes you have a working knowledge of Docker and Go. We'll go over the following:

\n\n

Environment Setup

\n

First, we need to set up the environment. Create a project and include the app we want to containerize:

\n
mkdir docker-go-tutorial && cd docker-go-tutorial && mkdir node-hello
\n

We'll add a simple Node.js app:

\n
// node-hello/app.js\nconsole.log("Hello From LoginRadius");
\n

with the Dockerfile:

\n
// node-hello/Dockerfile\nFROM node:12\nWORKDIR /src\nCOPY . .\nCMD [ "node", "app.js" ]
\n

Next, install the Go SDK. These are the Docker related imports we will be using:

\n
"github.com/docker/docker/api/types"\n"github.com/docker/docker/client"\n"github.com/docker/docker/pkg/archive"
\n

Build Docker Image

\n

One way to build a Docker image from our local files is to compress those files into a tar archive first.

\n

We use the archive package provided by Docker:

\n
"github.com/docker/docker/pkg/archive"
\n
tar, err := archive.TarWithOptions("node-hello/", &archive.TarOptions{})\nif err != nil {\n    return err\n}
\n

Now, we can call the ImageBuild function using the Go SDK:

\n\n

To print the response, we use a scanner to go through line by line:

\n
scanner := bufio.NewScanner(res.Body)\nfor scanner.Scan() {\n    lastLine = scanner.Text()\n    fmt.Println(scanner.Text())\n}
\n

This prints the following:

\n
{"stream":"Step 1/4 : FROM node:12"}\n{"stream":"\\n"}\n{"stream":" ---\\u003e e4f1e16b3633\\n"}\n{"stream":"Step 2/4 : WORKDIR /src"}\n{"stream":"\\n"}\n{"stream":" ---\\u003e Using cache\\n"}\n{"stream":" ---\\u003e b298b8519669\\n"}\n{"stream":"Step 3/4 : COPY . ."}\n{"stream":"\\n"}\n{"stream":" ---\\u003e Using cache\\n"}\n{"stream":" ---\\u003e 1ff6a87e79d9\\n"}\n{"stream":"Step 4/4 : CMD [ \\"node\\", \\"app.js\\" ]"}\n{"stream":"\\n"}\n{"stream":" ---\\u003e Using cache\\n"}\n{"stream":" ---\\u003e 6ca44f72b68d\\n"}\n{"aux":{"ID":"sha256:238a923459uf28h80103eb089804a2ff2c1f68f8c"}}\n{"stream":"Successfully built 6ca44f72b68d\\n"}\n{"stream":"Successfully tagged lrblake/node-hello:latest\\n"}
\n

The last step would be checking the response for errors, so if something went wrong during the build, we could handle it.

\n
errLine := &ErrorLine{}\njson.Unmarshal([]byte(lastLine), errLine)\nif errLine.Error != "" {\n    return errors.New(errLine.Error)\n}
\n

For example, the following error can occur during build:

\n
{"errorDetail":{"message":"COPY failed: stat /var/lib/docker/tmp/docker-builder887191115/z: no such file or directory"},"error":"COPY failed: stat /var/lib/docker/tmp/docker-builder887191115/z: no such file or directory"}
\n

All together, the file looks like this:

\n
package main\n\nimport (\n\t"bufio"\n\t"context"\n\t"encoding/json"\n\t"errors"\n\t"fmt"\n\t"io"\n\t"time"\n\n\t"github.com/docker/docker/api/types"\n\t"github.com/docker/docker/client"\n\t"github.com/docker/docker/pkg/archive"\n)\n\nvar dockerRegistryUserID = ""\n\ntype ErrorLine struct {\n\tError       string      `json:"error"`\n\tErrorDetail ErrorDetail `json:"errorDetail"`\n}\n\ntype ErrorDetail struct {\n\tMessage string `json:"message"`\n}\n\nfunc main() {\n\tcli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())\n\tif err != nil {\n\t\tfmt.Println(err.Error())\n\t\treturn\n\t}\n\n\terr = imageBuild(cli)\n\tif err != nil {\n\t\tfmt.Println(err.Error())\n\t\treturn\n\t}\n}\n\nfunc imageBuild(dockerClient *client.Client) error {\n\tctx, cancel := context.WithTimeout(context.Background(), time.Second*120)\n\tdefer cancel()\n\n\ttar, err := archive.TarWithOptions("node-hello/", &archive.TarOptions{})\n\tif err != nil {\n\t\treturn err\n\t}\n\n\topts := types.ImageBuildOptions{\n\t\tDockerfile: "Dockerfile",\n\t\tTags:       []string{dockerRegistryUserID + "/node-hello"},\n\t\tRemove:     true,\n\t}\n\tres, err := dockerClient.ImageBuild(ctx, tar, opts)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tdefer res.Body.Close()\n\n\terr = print(res.Body)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\treturn nil\n}\n\nfunc print(rd io.Reader) error {\n\tvar lastLine string\n\n\tscanner := bufio.NewScanner(rd)\n\tfor scanner.Scan() {\n\t\tlastLine = scanner.Text()\n\t\tfmt.Println(scanner.Text())\n\t}\n\n\terrLine := &ErrorLine{}\n\tjson.Unmarshal([]byte(lastLine), errLine)\n\tif errLine.Error != "" {\n\t\treturn errors.New(errLine.Error)\n\t}\n\n\tif err := scanner.Err(); err != nil {\n\t\treturn err\n\t}\n\n\treturn nil\n}
\n

The equivalent Docker CLI command would be:

\n
docker build -t <dockerRegistryUserID>/node-hello .
\n

Push Docker Image

\n

We'll push the Docker image we created to Docker Hub. But, we need to authenticate with Docker Hub by providing credentials encoded in base64.

\n\n

Now, call the ImagePush function in the Go SDK, along with your encoded credentials:

\n
opts := types.ImagePushOptions{RegistryAuth: authConfigEncoded}\nrd, err := dockerClient.ImagePush(ctx, dockerRegistryUserID + "/node-hello", opts)
\n

Together, this looks like:

\n
func imagePush(dockerClient *client.Client) error {\n\tctx, cancel := context.WithTimeout(context.Background(), time.Second*120)\n\tdefer cancel()\n\n\tauthConfigBytes, _ := json.Marshal(authConfig)\n\tauthConfigEncoded := base64.URLEncoding.EncodeToString(authConfigBytes)\n\n\ttag := dockerRegistryUserID + "/node-hello"\n\topts := types.ImagePushOptions{RegistryAuth: authConfigEncoded}\n\trd, err := dockerClient.ImagePush(ctx, tag, opts)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tdefer rd.Close()\n\n\terr = print(rd)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\treturn nil\n}
\n

The equivalent Docker CLI command (after docker login) would be:

\n
docker push <dockerRegistryUserID>/node-hello
\n","frontmatter":{"date":"December 08, 2020","updated_date":null,"title":"Build and Push Docker Images with Go","tags":["Docker","Go"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.680672268907563,"src":"/static/f7f513d2d6c5460c9f71278fcb98f766/ee604/cover.png","srcSet":"/static/f7f513d2d6c5460c9f71278fcb98f766/69585/cover.png 200w,\n/static/f7f513d2d6c5460c9f71278fcb98f766/497c6/cover.png 400w,\n/static/f7f513d2d6c5460c9f71278fcb98f766/ee604/cover.png 800w,\n/static/f7f513d2d6c5460c9f71278fcb98f766/31987/cover.png 1000w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Andy Yeung","github":null,"avatar":null}}}},{"node":{"fields":{"slug":"/engineering/golang-maps/"},"html":"

Golang Maps is a compilation of unordered key-value pairs. It is commonly used because it offers simple searches and values with the aid of keys that can be retrieved, modified or deleted. It is a reference to a table with a hash.

\n

This blog will cover the basic use of maps in Go, and how a newcomer to the language may utilize them for their applications.

\n

What is a Map?

\n

Maps (also called dictionaries) are a very useful tool in helping to store and organize objects to be accessed in an efficient method.

\n

Most basic implementations of a map involve using a key to access a value in the map, resulting in key-value pairs, in which one key is associated with a specific value in the map. Within Golang, maps follow this definition.

\n

\n \n \n

\n

How to create a map?

\n

Initialization of a map can be done using the make command. This is similar to the initialization of a slice:

\n
mapObject := make(map[string]string)
\n

In this case, mapObject is a map that uses strings as a key to map to another string. When creating a map, the key type must be a type that is Comparable, or more specifically types that can be compared using the == operator.

\n

Examples of valid key types include booleans, numbers, strings and several other primitives can be used as keys.

\n

One more thing to note is that structs can be used as a key, provided that all the properties of the struct are Comparable.

\n

Maps can also be created using a map literal. For an empty map:

\n
mapObject := map[string]string{}
\n

Or for a map with initial data:

\n
mapObject := map[string]string{\n\t“Key1”: “Value1”,\n\t“Key2”: “Value2”,\n\t“Key3”: “Value3”,\n}
\n

How to use Go Maps (with Examples)

\n

Setting

\n

Interaction with Go maps are similar to the dictionaries and maps of other languages. A simple way to return a value associated with the key is to use bracket notation. For example, to set a string value mapped to a string key:

\n
mapObject[“test”] = “test_value”
\n

Fetching

\n

\n \n \n

\n

Retrieving a value uses the same format.

\n
result := mapObject[“test”]
\n

The value of result will be the value assigned to “test” in the map. In the case where no key is found, the zero value of the type is returned instead. In this case, if there is no associated value with “test”, an empty string is returned.

\n

A boolean that returns the key’s existence can also be returned if two arguments are assigned from the retrieval. For example:

\n
result, exists := mapObject[“test”]
\n

If “test” exists in the map, result will be the value associated with “test” and exists will be true. If “test” does not exist, result will be an empty string and exists will be false. This is useful when the map being used contains zero-values to distinguish between existence or whether the value is just zero.

\n

Deleting

\n

Using Go’s built in delete method, key-value pairs can be deleted off the map. To delete the previous “test” key from the map, the following can be called:

\n
delete(mapObject, "test")
\n

The delete method does not have a return value, so if the key does not exist in the map, nothing will happen.\nLength

\n

The number of key-value pairs of a map can be found using the len method:

\n
length := len(mapObject)
\n

Iterating

\n

Using Go’s range keyword, a map can be iterated through.

\n
for key, value := range m {\n    fmt.Println("Key:", key, "Value:", value)\n}
\n

There is no specific order in which the map is iterated. If a specific order is needed, a slice or other data structure can be used to store or hold data which can then be sorted and iterated through.

\n

Concurrency

\n

Although Go has a lot of support for concurrency through the use of goroutines and channels, maps alone are not a reliable approach to handling data in a concurrent setting.

\n

To work with maps that support concurrency, a separate synchronization method should be used, like sync.RWMutex. Alternatively, an open source map package which implements the synchronizations can be used.

\n

Conclusion

\n

With the market space and number of applications being created by Go increasing, hopefully this blog will help touch onto the basics of one of the major structures in Go.

\n

Although it doesn’t support concurrency, maps in Go are still a useful tool in most applications developed in Go, to reliably access and manage data.

\n

If you want to learn more about golang here is a quick guide on, how to send email with golang. If you like what you read leave a comment or any question and will communicate further.

\n","frontmatter":{"date":"September 25, 2020","updated_date":null,"title":"Golang Maps - A Beginner’s Guide","tags":["Go","dictionaries","maps"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/30bb9b9901e76f3498d68913a0675ea9/ee604/index.png","srcSet":"/static/30bb9b9901e76f3498d68913a0675ea9/69585/index.png 200w,\n/static/30bb9b9901e76f3498d68913a0675ea9/497c6/index.png 400w,\n/static/30bb9b9901e76f3498d68913a0675ea9/ee604/index.png 800w,\n/static/30bb9b9901e76f3498d68913a0675ea9/f3583/index.png 1200w,\n/static/30bb9b9901e76f3498d68913a0675ea9/0dadc/index.png 1500w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Chris Yee","github":null,"avatar":null}}}},{"node":{"fields":{"slug":"/engineering/mongodb-as-datasource-in-golang/"},"html":"

Before You Get Started

\n

This tutorial assumes you have:

\n\n

In this tutorial, we will use the official MongoDB Go Driver to manage our MongoDB database. In the due process, we will write a program to learn how to install the MongoDB Go Driver and perform CRUD operations with it.

\n

Installation

\n

First in an empty folder run the below command

\n
go mod init gomongo
\n

go mod init creates a new go.mod file and automatically imports dependencies when you will run go program. Then create the file main.go and write the below code, We will explain what this code will do in a min.

\n
package main\n\nimport (\n    "context"\n    "fmt"\n    "log"\n\n    "go.mongodb.org/mongo-driver/bson"\n    "go.mongodb.org/mongo-driver/mongo"\n    "go.mongodb.org/mongo-driver/mongo/options"\n)\n\n// Book - We will be using this Book type to perform crud operations\ntype Book struct {\n  Title     string\n  Author    string\n  ISBN      string\n  Publisher string\n  Copies     int\n}\n\nfunc main() {\n    \n  // Set client options\n  clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")\n\n  // Connect to MongoDB\n  client, err := mongo.Connect(context.TODO(), clientOptions)\n\n  if err != nil {\n    log.Fatal(err)\n  }\n\n  // Check the connection\n  err = client.Ping(context.TODO(), nil)\n\n  if err != nil {\n    log.Fatal(err)\n  }\n\n  fmt.Println("Connected to MongoDB!")\n  booksCollection := client.Database("testdb").Collection("books")\n}
\n

In the above code, we have imported the bson, mongo, and mongo/options packages of mongo-driver and defined a Book type which will be used in this tutorial

\n

In the main function first, we created clientOptions with MongoDB URL and credentials and pass it to mongo.Connect function, Once connected we can check our connection by client.Ping function.

\n

The following code will use booksCollection variable to query the books collection from testdb.

\n
booksCollection := client.Database("testdb").Collection("books")
\n

Insert Documents

\n

First Let's create a Book struct to insert into the collection, in below code we are using collection.InsertOne function to insert a single document in the collection

\n
// Insert One document\nbook1 := Book{"Animal Farm", "George Orwell", "0451526341", "Signet Classics", 100}\ninsertResult, err := booksCollection.InsertOne(context.TODO(), book1)\nif err != nil {\n    log.Fatal(err)\n}\n\nfmt.Println("Inserted a single document: ", insertResult.InsertedID)
\n

To insert multiple documents at once we need to create a slice of Book object and pass it to collection.InsertMany

\n
// Insert multiple documents\nbook2 := Book{"Super Freakonomics", "Steven D. Levitt", "0062312871", "HARPER COLLINS USA", 100}\nbook3 := Book{"The Alchemist", "Paulo Coelho", "0062315005", "HarperOne", 100}\nmultipleBooks := []interface{}{book2, book3}\n\ninsertManyResult, err := booksCollection.InsertMany(context.TODO(), multipleBooks)\nif err != nil {\n    log.Fatal(err)\n}\n\nfmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs)
\n

Update Documents

\n

We can update a single document by function collection.UpdateOne. It requires a filter document to match documents in the collection and an updated document to describe the update operation. You can build these using bson.D types. The below code will match the book with ISBN 0451526341 and increment the copies field by 10

\n
//Update one document\nfilter := bson.D{{"isbn", "0451526341"}}\n\nupdate := bson.D{\n    {"$inc", bson.D{\n        {"copies", 10},\n    }},\n}\n\nupdateResult, err := booksCollection.UpdateOne(context.TODO(), filter, update)\nif err != nil {\n    log.Fatal(err)\n}\n\nfmt.Printf("Matched %v documents and updated %v documents.\\n", updateResult.MatchedCount, updateResult.ModifiedCount)
\n
\n

You can also update more than one documents at once in a single collection by function collection.UpdateMany, In it, we need to pass filter document and update document same as collection.UpdateOne

\n
\n

Find Documents

\n

To find a single document, we can use function collection.FindOne(), we will pass a filter document and decode the result in the Book type variable

\n
// A variable in which result will be decoded\nvar result Book\n\nerr = booksCollection.FindOne(context.TODO(), filter).Decode(&result)\nif err != nil {\n    log.Fatal(err)\n}\n\nfmt.Printf("Found a single document: %+v\\n", result)
\n

To find multiple documents, we use function collection.Find(). This method returns a Cursor, It provides a stream of documents on which we can iterate or we can get all the docs by function cursor.All() in a slice of Book type.

\n
cursor, err := booksCollection.Find(context.TODO(), bson.D{{}})\nif err != nil {\n  log.Fatal(err)\n}\nvar books []Book\nif err = cursor.All(context.TODO(), &books); err != nil {\n  log.Fatal(err)\n}\nfmt.Printf("Found multiple documents: %+v\\n", books)
\n

Delete Documents

\n

We can delete documents from a collection using functions collection.DeleteOne() or collection.DeleteMany(). Here you pass bson.D{{}} as the filter argument, which will match all documents in the collection.

\n
deleteCollection, err := booksCollection.DeleteMany(context.TODO(), bson.D{{}})\nif err != nil {\n    log.Fatal(err)\n}\nfmt.Printf("Deleted %v documents in the books collection\\n", deleteCollection.DeletedCount)
\n
\n

Entire collection can be dropped using the collection.Drop() function, it will remove all documents and metadata, such as indexes from the collection

\n
\n

Once you have done all the operation, don't forget to close the MongoDB connection

\n
err = client.Disconnect(context.TODO())\n\nif err != nil {\n    log.Fatal(err)\n}\n\nfmt.Println("Connection to MongoDB closed.")
\n

Now you can easily use MongoDB as Datasource in your go application, You can found the complete code used in this tutorial on our Github Repo

\n","frontmatter":{"date":"September 21, 2020","updated_date":null,"title":"Using MongoDB as Datasource in GoLang","tags":["Go","MongoDB"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/462778a1e1bc2468232a76699885ec69/ee604/gomongo.png","srcSet":"/static/462778a1e1bc2468232a76699885ec69/69585/gomongo.png 200w,\n/static/462778a1e1bc2468232a76699885ec69/497c6/gomongo.png 400w,\n/static/462778a1e1bc2468232a76699885ec69/ee604/gomongo.png 800w,\n/static/462778a1e1bc2468232a76699885ec69/f3583/gomongo.png 1200w,\n/static/462778a1e1bc2468232a76699885ec69/5707d/gomongo.png 1600w,\n/static/462778a1e1bc2468232a76699885ec69/eeb1b/gomongo.png 1920w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/what-is-the-new-go-1-15/"},"html":"

Go announced Go 1.15 version on 11 Aug 2020. Highlighted updates and features include Substantial improvements to the Go linker, Improved allocation for small objects at high core counts, X.509 CommonName deprecation, GOPROXY supports skipping proxies that return errors, New embedded tzdata package, Several Core Library improvements and more.

\n

As Go promise for maintaining backward compatibility. After upgrading to the latest Go 1.15 version, almost all existing Golang applications or programs continue to compile and run as older Golang version.

\n

Download the latest Go Version from Golang.

\n

Operating system and platform compatibility

\n

macOS

\n

Go 1.14 version announced some changes for the macOS. According to announcement

\n
\n

Go 1.14 is the last release that will run on macOS 10.11 El Capitan. Go 1.15 will require macOS 10.12 Sierra or later.

\n
\n

The lastest macOS 10.15 (Catalina) is no longer supporting 32-bit binaries. Go 1.14 will likely to be the last Go release to support 32-bit binaries on iOS, iPadOS, watchOS, and tvOS (the darwin/arm port). Go continues to support the 64-bit darwin/amd64 port.

\n

Windows

\n

Go now generates Windows ASLR executables when -buildmode=pie cmd/link flag is provided. Go command uses -buildmode=pie by default on Windows.

\n

The -race and -msan flags now always enable -d=checkptr, which checks uses of unsafe. Pointer. This was previously the case on all OSes except Windows.

\n

Android

\n

Mobile applications were crashing in some devices due to some invalid lld linker versions so now avoiding the crashing the latest Go 1.15 version explicitly selects the lld linker available in recent versions of the NDK. This explicitly lld linker avoids crashes on some devices. it becomes the default NDK linker in a future NDK version.

\n

Smaller binaries & Performance improvements

\n

Always new Go 1.15 brings many minor/major performance improvements. The first major improvement has reduced the executable's binary size by almost 5% - 10% as compared to Go 1.14. As Brad Fitzpatrick tweet, test program down from 8.2MB in Go 1.14 to 3.9MB in 1.15.

\n

\n \n \n

\n

\n \n \n

\n

Go 1.15 has improved the code build process now unused code is eliminating in the new linker, along with several targeted improvements, such as Clements's CL 230544, which reduces the number of stack and register maps included in the executable.

\n

Standard library additions

\n

Always in every new version release Go come with various minor changes and updates to the library. I m including some useful and important changes

\n

tzdata Package

\n

A new embedded tzdata package was added that permits embedding the timezone database into a program. Importing this package (as import _ \"time/tzdata\") which allows the program to find timezone information without the timezone database on the local system. We can also embed the timezone database by building with -tags timet/zdata. This approach increases the size of the program by about 800 KB. This might be useful and can test some code with the virtualized environments like Go playground.

\n

X.509 CommonName deprecation

\n

Go older versions were using CommonName field on X.509 certificates as a hostname if there is no Subject\nAlternative Names, would be disabled by default. If Still want to use this legacy behavior then we need to add x509ignoreCN=0 in the GODEBUG environment variable.

\n

net/url Package

\n

The net/url package adds a new URL. The redacted () method that returns the URL as a string. This is proposed in the Issue 34855. It is a very useful improvement for audit logging and security. It's a simple derivation from the URL.String() that masks the password if exists from the string being passed. It does not modify at all to the URL itself but a copy of it.

\n

Summary

\n

Go 1.15 has released with various improvements, bug fixes. We can get all improvements, closed proposals and features details for the Go GitHub repository.

\n

Referance

\n\n","frontmatter":{"date":"September 07, 2020","updated_date":null,"title":"What's new in the go 1.15","tags":["Go","Golang","Go 1.15"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/d85b112d59a5149f84548b866984f6db/ee604/index.png","srcSet":"/static/d85b112d59a5149f84548b866984f6db/69585/index.png 200w,\n/static/d85b112d59a5149f84548b866984f6db/497c6/index.png 400w,\n/static/d85b112d59a5149f84548b866984f6db/ee604/index.png 800w,\n/static/d85b112d59a5149f84548b866984f6db/f3583/index.png 1200w,\n/static/d85b112d59a5149f84548b866984f6db/5707d/index.png 1600w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Vijay Singh Shekhawat","github":"code-vj","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/sending-emails-with-golang/"},"html":"

Before You Get Started

\n

This tutorial assumes you have:

\n\n

In this blog, we’ll look at different methods to send an email with Go, First, we will explore inbuilt smtp package, then we will move to use a popular package Gomail and finally, we will send HTML emails using custom templates.

\n

Package smtp

\n

smtp is an inbuilt package provided with Golang. It implements the Simple Mail Transfer Protocol and has multiple functionalities related to it. Here to send the email we will be using only two functions PlainAuth and SendMail from the package.

\n
\n

Note: Click here for an overview on Go Functions

\n
\n\n

Below is the complete code to send a plain text email with smtp package in golang.

\n
package main\n\nimport (\n  "fmt"\n  "net/smtp"\n)\n\nfunc main() {\n\n  // Sender data.\n  from := "from@gmail.com"\n  password := "<Email Password>"\n\n  // Receiver email address.\n  to := []string{\n    "sender@example.com",\n  }\n\n  // smtp server configuration.\n  smtpHost := "smtp.gmail.com"\n  smtpPort := "587"\n\n  // Message.\n  message := []byte("This is a test email message.")\n  \n  // Authentication.\n  auth := smtp.PlainAuth("", from, password, smtpHost)\n  \n  // Sending email.\n  err := smtp.SendMail(smtpHost+":"+smtpPort, auth, from, to, message)\n  if err != nil {\n    fmt.Println(err)\n    return\n  }\n  fmt.Println("Email Sent Successfully!")\n}
\n
\n

In the above code example we have used smtp details of a Gmail account, you should update the smtp detail according to your email provider.

\n
\n
\n

Just to explain things easily, In the above snippet, we have written all the smtp and email credentials in the main function, Though in a production app you should always use env variables for configurations. You can check Viper to manage configurations in production apps.

\n
\n

Package Gomail

\n

Below is the complete code to send a plain text email with Gomail package in golang.

\n
package main\n\nimport (\n  "crypto/tls"\n  "fmt"\n\n  gomail "gopkg.in/mail.v2"\n)\n\nfunc main() {\n  m := gomail.NewMessage()\n\n  // Set E-Mail sender\n  m.SetHeader("From", "from@gmail.com")\n\n  // Set E-Mail receivers\n  m.SetHeader("To", "to@example.com")\n\n  // Set E-Mail subject\n  m.SetHeader("Subject", "Gomail test subject")\n\n  // Set E-Mail body. You can set plain text or html with text/html\n  m.SetBody("text/plain", "This is Gomail test body")\n\n  // Settings for SMTP server\n  d := gomail.NewDialer("smtp.gmail.com", 587, "from@gmail.com", "<email_password>")\n\n  // This is only needed when SSL/TLS certificate is not valid on server.\n  // In production this should be set to false.\n  d.TLSConfig = &tls.Config{InsecureSkipVerify: true}\n\n  // Now send E-Mail\n  if err := d.DialAndSend(m); err != nil {\n    fmt.Println(err)\n    panic(err)\n  }\n\n  return\n}
\n

Custom HTML Templates

\n

Now, let's send an HTML email with smtp package, for this, we need to create two files in the root folder.

\n\n
<!-- template.html -->\n<!DOCTYPE html>\n<html>\n<body>\n    <h3>Name:</h3><span>{{.Name}}</span><br/><br/>\n    <h3>Email:</h3><span>{{.Message}}</span><br/>\n</body>\n</html>
\n

We are using text/template package to parse HTML files and use it in smtp SendMail function.

\n
package main\n\nimport (\n  "bytes"\n  "fmt"\n  "net/smtp"\n  "text/template"\n)\n\nfunc main() {\n\n  // Sender data.\n  from := "from@gmail.com"\n  password := "<Email Password>"\n\n  // Receiver email address.\n  to := []string{\n    "sender@example.com",\n  }\n\n  // smtp server configuration.\n  smtpHost := "smtp.gmail.com"\n  smtpPort := "587"\n\n  // Authentication.\n  auth := smtp.PlainAuth("", from, password, smtpHost)\n\n  t, _ := template.ParseFiles("template.html")\n\n  var body bytes.Buffer\n\n  mimeHeaders := "MIME-version: 1.0;\\nContent-Type: text/html; charset=\\"UTF-8\\";\\n\\n"\n  body.Write([]byte(fmt.Sprintf("Subject: This is a test subject \\n%s\\n\\n", mimeHeaders)))\n\n  t.Execute(&body, struct {\n    Name    string\n    Message string\n  }{\n    Name:    "Puneet Singh",\n    Message: "This is a test message in a HTML template",\n  })\n\n  // Sending email.\n  err := smtp.SendMail(smtpHost+":"+smtpPort, auth, from, to, body.Bytes())\n  if err != nil {\n    fmt.Println(err)\n    return\n  }\n  fmt.Println("Email Sent!")\n}
\n

Once done you need to run below command to send the emails

\n
go run main.go
\n
\n

If you don't want to create your custom HTML emails, Hermes is a package that generates clean, responsive HTML e-mails for sending transactional e-mails.

\n
\n

Now you can send beautiful emails to the customer by your golang application, You can found the complete code used in this blog on our Github Repo

\n","frontmatter":{"date":"August 03, 2020","updated_date":null,"title":"Different ways to send an email with Golang","tags":["Go","Email"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/0ac40484af2392675963fb3327b3dbb4/14b42/email_cover.jpg","srcSet":"/static/0ac40484af2392675963fb3327b3dbb4/f836f/email_cover.jpg 200w,\n/static/0ac40484af2392675963fb3327b3dbb4/2244e/email_cover.jpg 400w,\n/static/0ac40484af2392675963fb3327b3dbb4/14b42/email_cover.jpg 800w,\n/static/0ac40484af2392675963fb3327b3dbb4/47498/email_cover.jpg 1200w,\n/static/0ac40484af2392675963fb3327b3dbb4/0e329/email_cover.jpg 1600w,\n/static/0ac40484af2392675963fb3327b3dbb4/52258/email_cover.jpg 1800w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/twitter-authentication-with-golang-and-goth/"},"html":"

In this blog, we’ll be implementing authentication via Twitter in a Golang web application. For this, we’ll be using Goth, a social authentication middleware for Golang.

\n

Pre-requisites:

\n\n

Firstly, We need to create a new Twitter App using its Application Management. Twitter does not seem to work nicely with it if \"localhost\" is given in the callback URL field. To overcome this limitation, you could use the special loopback address or \"127.0.0.1\" in place of \"localhost\".

\n

Step 1. First, create a directory structure as below for your Go Application :

\n
TwitterAuthenticationGoth\n-templates\n--index.html\n--success.html\n-main.go
\n

Step 2. Add the following code in index.html for creating LoginUI:

\n
<!doctype html>\n<html>\n<head>\n    <title>Twitter SignIn</title>\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n    <style>\n        body        { padding-top:70px; }\n    </style>\n</head>\n<body>\n<div class="container">\n    <div class="jumbotron text-center text-success">\n        <h1><span class="fa fa-lock"></span> Social Authentication</h1>\n        <p>Login or Register with:</p>\n        <a href="/auth/twitter" class="btn btn-danger"><span class="fa fa-twitter"></span> SignIn with Twitter</a>\n    </div>\n</div>\n</body>\n</html>
\n

Step 3 Add the following code in success.html for creating ProfileUI:

\n
<!doctype html>\n<html>\n  <head>\n    <title>Twitter SignIn</title>\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n      <style>\n          body        { padding-top:70px; }\n      </style>\n  </head>\n  <body>\n    <div class="container">\n      <div class="jumbotron">\n          <h1 class="text-success  text-center"><span class="fa fa-user"></span> Profile Information</h1>\n          <div class="row">\n            <div class="col-sm-6">\n                <div class="well">\n                        <p>\n                            <strong>Id</strong>: {{.UserID}}<br>\n                            <strong>Email</strong>: {{.Email}}<br>\n                            <strong>Name</strong>: {{.Name}}\n                        </p>\n                </div>\n            </div>\n        </div>\n      </div>\n    </div>\n  </body>\n</html>
\n

Step 4. Add the following code in main.go for importing Goth and other packages :

\n
import (\n    "fmt"\n    "html/template"\n    "log"\n    "net/http"\n    "sort"\n\n    "github.com/gorilla/pat"\n    "github.com/markbates/goth"\n    "github.com/markbates/goth/gothic"\n    "github.com/markbates/goth/providers/twitter"\n)
\n

Now we are ready to implement Twitter Authentication in our app

\n

Step 5. Setup the twitter configuration by adding the following code in main.go :

\n
goth.UseProviders(\n        twitter.New("TWITTER_KEY", "TWITTER_SECRET", "http://127.0.0.1:3000/auth/twitter/callback"),\n\n    )
\n

Step 6. For adding all routes and functionality you just need to add following code in main.go :

\n
 type ProviderIndex struct {\n     Providers[] string\n     ProvidersMap map[string] string\n }\n\n func main() {\n     goth.UseProviders(\n         twitter.New("TWITTER_KEY", "TWITTER_SECRET", "http://127.0.0.1:3000/auth/twitter/callback"),\n         // If you'd like to use authenticate instead of authorize in Twitter provider, use this instead.\n         // twitter.NewAuthenticate(os.Getenv("TWITTER_KEY"), os.Getenv("TWITTER_SECRET"), "http://localhost:3000/auth/twitter/callback"),\n     )\n\n     m: = make(map[string] string)\n     m["twitter"] = "Twitter"\n\n     var keys[] string\n     for k: = range m {\n         keys = append(keys, k)\n     }\n     sort.Strings(keys)\n\n     providerIndex: = & ProviderIndex {\n         Providers: keys,\n         ProvidersMap: m\n     }\n\n     p: = pat.New()\n     p.Get("/auth/{provider}/callback", func(res http.ResponseWriter, req * http.Request) {\n\n         user, err: = gothic.CompleteUserAuth(res, req)\n         if err != nil {\n             fmt.Fprintln(res, err)\n             return\n         }\n         t, _: = template.ParseFiles("templates/success.html")\n         t.Execute(res, user)\n     })\n\n     p.Get("/logout/{provider}", func(res http.ResponseWriter, req * http.Request) {\n         gothic.Logout(res, req)\n         res.Header().Set("Location", "/")\n         res.WriteHeader(http.StatusTemporaryRedirect)\n     })\n\n     p.Get("/auth/{provider}", func(res http.ResponseWriter, req * http.Request) {\n         // try to get the user without re-authenticating\n         if gothUser, err: = gothic.CompleteUserAuth(res, req);\n         err == nil {\n             t, _: = template.ParseFiles("templates/success.html")\n             t.Execute(res, gothUser)\n         } else {\n             gothic.BeginAuthHandler(res, req)\n         }\n     })\n\n     p.Get("/", func(res http.ResponseWriter, req * http.Request) {\n         t, _: = template.ParseFiles("templates/index.html")\n         t.Execute(res, providerIndex)\n     })\n     log.Println("listening on localhost:3000")\n     log.Fatal(http.ListenAndServe(":3000", p))\n }
\n

Now you just need to run the project by using the following command and try logging by using the Twitter button.

\n

Step 7. Run the project :

\n
 go run main.go
\n

Step 8. Visit the browser with the URL http://127.0.0.1:3000.

\n

\n \n \n

\n

After login with our twitter credentials, it will redirect back to our application and on the success page, we can see the details of the logged-in user and can save this detail in the database for future use also.

\n

\n \n \n

\n

As we have seen it is fairly easy to build a twitter social authentication system with Go and Goth, You can found the complete code used in this tutorial on our Github Repo

\n","frontmatter":{"date":"June 15, 2020","updated_date":null,"title":"Twitter authentication with Go Language and Goth","tags":["Go","SocialLogin","Oauth"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/128533caa8a4ba717d200f38198342e4/14b42/cover.jpg","srcSet":"/static/128533caa8a4ba717d200f38198342e4/f836f/cover.jpg 200w,\n/static/128533caa8a4ba717d200f38198342e4/2244e/cover.jpg 400w,\n/static/128533caa8a4ba717d200f38198342e4/14b42/cover.jpg 800w,\n/static/128533caa8a4ba717d200f38198342e4/47498/cover.jpg 1200w,\n/static/128533caa8a4ba717d200f38198342e4/0e329/cover.jpg 1600w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Ashish Sharma","github":"ashish8947","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/google-authentication-with-golang-and-goth/"},"html":"

In this blog, we’ll be implementing authentication via Google in a Go web application. For this, we’ll be using Goth - Multi-Provider Authentication Package for Go

\n

Before You Get Started

\n

This tutorial assumes you have:

\n\n

Step 1: Create a Google client ID and client secret

\n

We can create a client ID and client secret using its Google API Console. You need to follow below steps once you open Google API Console

\n\n

Note: If Google doesn't support http://localhost:3000, then use http://127.0.0.1:3000

\n

Step 2: Initialize a Go project using Go modules

\n

First in an empty folder run the below command

\n
go mod init googleauth
\n

go mod init creates a new go.mod file and automatically imports dependencies when you will run go program

\n

Step 3: Writing golang server code to accept web requests

\n

Create a file main.go in the root folder of your app and add the following code:

\n

A small description for packages used in below code

\n\n
package main\n\nimport (\n  "fmt"\n  "html/template"\n  "net/http"\n  \n\n  "log"\n\n  "github.com/gorilla/pat"\n  "github.com/markbates/goth"\n  "github.com/markbates/goth/gothic"\n  "github.com/markbates/goth/providers/google"\n  "github.com/gorilla/sessions"\n)\n\n\nfunc main() {\n  \n  key := "Secret-session-key"  // Replace with your SESSION_SECRET or similar\n  maxAge := 86400 * 30  // 30 days\n  isProd := false       // Set to true when serving over https\n\n  store := sessions.NewCookieStore([]byte(key))\n  store.MaxAge(maxAge)\n  store.Options.Path = "/"\n  store.Options.HttpOnly = true   // HttpOnly should always be enabled\n  store.Options.Secure = isProd\n\n  gothic.Store = store\n\n  goth.UseProviders(\n    google.New("our-google-client-id", "our-google-client-secret", "http://localhost:3000/auth/google/callback", "email", "profile"),\n  )\n\n  p := pat.New()\n  p.Get("/auth/{provider}/callback", func(res http.ResponseWriter, req *http.Request) {\n\n    user, err := gothic.CompleteUserAuth(res, req)\n    if err != nil {\n      fmt.Fprintln(res, err)\n      return\n    }\n    t, _ := template.ParseFiles("templates/success.html")\n    t.Execute(res, user)\n  })\n\n  p.Get("/auth/{provider}", func(res http.ResponseWriter, req *http.Request) {\n    gothic.BeginAuthHandler(res, req)\n  })\n\n  p.Get("/", func(res http.ResponseWriter, req *http.Request) {\n    t, _ := template.ParseFiles("templates/index.html")\n    t.Execute(res, false)\n  })\n  log.Println("listening on localhost:3000")\n  log.Fatal(http.ListenAndServe(":3000", p))\n}
\n

Note: The callback URL in google.New should be the same as used in the google app configuration.

\n

If it is hard to understand the code, Here is the description of all the routes used in the code mentioned above

\n\n

Step 4: Creating a Login and Profile page

\n

Create an html file under path templates/index.html, it will render into a nice looking social login page:

\n
<!-- templates/index.html -->\n<!doctype html>\n<html>\n<head>\n    <title>Google SignIn</title>\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n    <style>\n        body        { padding-top:70px; }\n    </style>\n</head>\n<body>\n<div class="container">\n    <div class="jumbotron text-center text-success">\n        <h1><span class="fa fa-lock"></span> Social Authentication</h1>\n        <p>Login or Register with:</p>\n        <a href="/auth/google" class="btn btn-danger"><span class="fa fa-google"></span> SignIn with Google</a>\n    </div>\n</div>\n</body>\n</html>
\n

After it we will create an Html file under path templates/success.html, it will be used to show the user profile information we will get after authenticated by google

\n
<!-- templates/success.html -->\n<!doctype html>\n<html>\n  <head>\n    <title>Google SignIn</title>\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> <!-- load bulma css -->\n    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css"> <!-- load fontawesome -->\n      <style>\n          body        { padding-top:70px; }\n      </style>\n  </head>\n  <body>\n    <div class="container">\n      <div class="jumbotron">\n          <h1 class="text-success  text-center"><span class="fa fa-user"></span> Profile Information</h1>\n          <div class="row">\n            <div class="col-sm-6">\n                <div class="well">\n                        <p>\n                            <strong>Id</strong>: {{.UserID}}<br>\n                            <strong>Email</strong>: {{.Email}}<br>\n                            <strong>Name</strong>: {{.Name}}\n                        </p>\n                </div>\n            </div>\n        </div>\n      </div>\n    </div>\n  </body>\n</html>
\n

Note: Here we are also using bootstrap and font-awesome css to make our web pages look good.

\n

We have finished building our social login page, let's run the application by below command

\n
go run main.go
\n

Once our server is running, we can see our social login page on http://localhost:3000/

\n

\n \n \n

\n

We need to click on SignIn with Google button, which will redirect us to the google login page.

\n

\n \n \n

\n

After login with our google credentials, it will redirect back to our application and on the success page, we can see the details of the logged-in user and can save this detail in a database for future use also.

\n

\n