AWS EC2 is a virtual computing environment (known as instances) to develop and deploy applications. To create an EC2 instance in AWS, we need an active Amazon Web Services account.
\nFirst, let's login into our AWS account. Once login, we will land on the Management Console page, we can see all the AWS services.
\nThere is a drop-down on the top left corner, which is one more option to search and browse all the services provided by AWS. You can find EC2 under the Compute category.
There is a button Launch Instance to create a new instance in the selected region on the dashboard's bottom section.
After clicking the Launch button, we need to select the Amazon Machine Image (AMI) it includes the operating system and applications required to launch an instance. Here we will select the Ubuntu Server 20.04 LTS as shown in the below snapshot.
\nWe can increase or decrease the size of instance storage while creating it; the free tier is eligible upto 30GB; if you need more storage, it will be billed according to Elastic Block Store (EBS) Pricing
\nOn the next screen, we can add tags to our instance and storage; these tags are key-value pair which are very useful to add properties to our resources, especially when we have multiple instances.
\nWe can define the firewall rules in a security group attached to our instance. With the help of these rules, we can control the traffic to our instance.
\nOnce we are done with firewall rules, we can review the complete detail of our new instance on a single page, and here we can click Launch button to launch the instance.
When we click Launch, it will open a pop-up that will require you to select a pre-existing public-private key-pair or create one to connect to our instance securely. Once you select/download the key, you will be able to launch the instance.
It will take approximately 5-10 min to launch the instance. Once launched, You can see the list of your running instances by clicking on the Instances button on the left menu.
// 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)To insert multiple documents at once we need to create a slice of Book object and pass it to collection.InsertMany
// 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)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
//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\nYou can also update more than one documents at once in a single collection by function
\ncollection.UpdateMany, In it, we need to pass filter document and update document same ascollection.UpdateOne
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
// 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)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.
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)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.
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\nEntire collection can be dropped using the collection.Drop() function, it will remove all documents and metadata, such as indexes from the collection
\n
Once you have done all the operation, don't forget to close the MongoDB connection
\nerr = client.Disconnect(context.TODO())\n\nif err != nil {\n log.Fatal(err)\n}\n\nfmt.Println("Connection to MongoDB closed.")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":{"title":"Using MongoDB as Datasource in GoLang","author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null},"date":"September 21, 2020","updated_date":null,"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"}}}},"fields":{"authorId":"Puneet Singh","slug":"/engineering/mongodb-as-datasource-in-golang/"}}},{"node":{"id":"22ca83c0-4d5f-5977-baff-e0bfc911ee4f","html":"This tutorial assumes you have:
\nIn 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.
\nsmtp 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\n\n
Below is the complete code to send a plain text email with smtp package in golang.
\npackage 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\nIn 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\nJust 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
Below is the complete code to send a plain text email with Gomail package in golang.
\npackage 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}Now, let's send an HTML email with smtp package, for this, we need to create two files in the root folder.
\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>We are using text/template package to parse HTML files and use it in smtp SendMail function.
\npackage 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}Once done you need to run below command to send the emails
\ngo run main.go\n\nIf 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
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":{"title":"Different ways to send an email with Golang","author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null},"date":"August 03, 2020","updated_date":null,"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"}}}},"fields":{"authorId":"Puneet Singh","slug":"/engineering/sending-emails-with-golang/"}}},{"node":{"id":"9db90870-a971-5cfa-96c6-f133d3079d77","html":"In this blog, we’ll see how to create and validate a JWT(JSON Web Token) in Deno. For this, we’ll be using djwt, the absolute minimum library to make JSON Web Tokens in deno and Oak framework
\nThis tutorial assumes you have:
\nJSON Web Token is an internet standard used to create tokens for an application. These tokens hold JSON data and are cryptographically signed.
\nHere is how a sample Json Web Token looks like
\neyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbWFpbCI6Im9sYXR1bmRlZ2FydWJhQGdtYWlsLmNvbSIsImJWT is a good way of securely sending information between parties. Because JWTs can be signed—for, you can be sure the senders are who they say they are. And, as the signature is generated using the header and the payload, you can also verify that the content hasn't been tampered with.
\nJWT can contain user information in the payload and also can be used in the session to authenticate the user.
\nIf you want to know more about JSON Web Token, We have a very good article about it.
\nFirst, let's set up a Deno server to accept requests, for it, we are using Oak framework, it is quite simple and few lines of codes as you can see below.
\n// index.ts\nimport { Application, Router } from "https://deno.land/x/oak/mod.ts";\n\nconst router = new Router();\nrouter\n .get("/", (context) => {\n context.response.body = "JWT Example!";\n })\n\nconst app = new Application();\napp.use(router.routes());\napp.use(router.allowedMethods());\n\nawait app.listen({ port: 8000 });Once our program is ready for accepting request Let's import djwt functions to generate JWT token, In below code we can use a secret key, expiry time for JWT token in 1 hour from the time program will run and we are using HS256 algorithm.
\nAdd the below code in index.ts and update the router as shown below, you can now get a brand new token on http://localhost:8000/generate
// index.ts\n...\n\nimport { makeJwt, setExpiration, Jose, Payload } from "https://deno.land/x/djwt/create.ts";\n\nconst key = "secret-key";\nconst payload: Payload = {\n iss: "Jon Doe",\n exp: setExpiration(new Date().getTime() + 60000),\n};\nconst header: Jose = {\n alg: "HS256",\n typ: "JWT",\n};\n\n\nconst router = new Router();\nrouter\n .get("/", (context) => {\n context.response.body = "JWT Example!";\n })\n .get("/generate", (context) => {\n context.response.body = makeJwt({ header, payload, key }) + "\\n";\n })\n\n...Once you get a JWT token you can validate the token by validateJwt function in djwt, let us import the validateJwt and add one more route /validate/:token
Now you can verify any token by passing it to a route like - http://localhost:8000/validate/jwt_token (jwt_token is a placeholder, please replace it with a real JWT token)
// index.ts\n...\n\nimport { validateJwt } from "https://deno.land/x/djwt/validate.ts";\n\n...\n\nrouter\n .get("/", (context) => {\n context.response.body = "JWT Example!";\n })\n .get("/generate", (context) => {\n context.response.body = makeJwt({ header, payload, key }) + "\\n";\n })\n .get("/validate/:token", async (context) => {\n if ( context.params && context.params.token && (await validateJwt(context.params.token, key)).isValid) {\n context.response.body = "Valid JWT\\n";\n } else {\n context.response.body = "Invalid JWT\\n";\n }\n });\n\n...Now you know how to generate and verify a JWT token in Deno, you can easily use it in your application, The complete source code used in this blog can be found in this Github Repo
\n","frontmatter":{"title":"How to create and validate JSON Web Tokens in Deno","author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null},"date":"July 10, 2020","updated_date":null,"tags":["Deno","JWT","JSON Web Token"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.492537313432836,"src":"/static/4f62fb01daec253b0246b5ba0f244846/ee604/deno_jwt.png","srcSet":"/static/4f62fb01daec253b0246b5ba0f244846/69585/deno_jwt.png 200w,\n/static/4f62fb01daec253b0246b5ba0f244846/497c6/deno_jwt.png 400w,\n/static/4f62fb01daec253b0246b5ba0f244846/ee604/deno_jwt.png 800w","sizes":"(max-width: 800px) 100vw, 800px"}}}},"fields":{"authorId":"Puneet Singh","slug":"/engineering/jwt-authentication-with-deno/"}}},{"node":{"id":"3e648e6e-dd61-5188-8294-809a2a6a11cd","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
\nThis tutorial assumes you have:
\nWe 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
\nhttp://localhost:3000/auth/google/callbackNote: If Google doesn't support http://localhost:3000, then use http://127.0.0.1:3000
First in an empty folder run the below command
\ngo mod init googleauthgo mod init creates a new go.mod file and automatically imports dependencies when you will run go program
Create a file main.go in the root folder of your app and add the following code:
\nA small description for packages used in below code
\npackage 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}Note: The callback URL in google.New should be the same as used in the google app configuration.
If it is hard to understand the code, Here is the description of all the routes used in the code mentioned above
\ngothic.BeginAuthHandler will redirect you to google authentication URLCreate 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> 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>Note: Here we are also using bootstrap and font-awesome css to make our web pages look good.
\nWe have finished building our social login page, let's run the application by below command
\ngo run main.goOnce our server is running, we can see our social login page on http://localhost:3000/
We need to click on SignIn with Google button, which will redirect us to the google login page.
\nAfter 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.
\nFirst, add a file called quotes.txt in the folder you want to run the Deno code, We will read these quotes with the help of Deno
\nDon't worry about what anybody else is going to do. The best way to predict the future is to invent it. - Alan Kay\nPremature optimization is the root of all evil in programming. - Donald Knuth\nClarity and brevity sometimes are at odds. When they are, I choose clarity. - Jacob Kaplan-Moss\nOptimism is an occupational hazard of programming; feedback is the treatment. - Kent Beck\nA lot of times, people don't know what they want until you show it to them. - Steve Jobs\nNine people can't make a baby in a month. - Fred Brooks\nA clever person solves a problem. A wise person avoids it. - Albert EinsteinAnd then create an index.ts file in which we will write Deno code, we can also write Deno code in javascript instead of Typescript, but as Deno is built on TypeScript we are using Typescript here
\nconst getQuotes = async (fileName: string): Promise<Array<string>> => {\n const decoder = new TextDecoder("utf-8");\n\n const text: string = decoder.decode(await Deno.readFile(fileName));\n return text.split("\\n");\n};\n\nconst quotesArr: Array<string> = await getQuotes("quotes.txt");\n\nconst randomQuote: string = quotesArr[Math.floor(Math.random() * quotesArr.length)];\nconsole.log(randomQuote);In the getQuotes function, we are using Deno.readFile #readfile to read the contents of a file as an array of bytes and using TextDecoder to convert the bytes to string and then splitting it in a string array and return
Then we are just picking a randomQuote with Math.random and console.log that on our screen
To run the above code we need to put --allow-read flag in our command as shown below because we need to access the local filesystem to read the file.
deno run --allow-read index.tsDeno is secure by default, with no file, network, or environment access unless explicitly enabled. You can run deno run --help to see all the available flags for different permissions
Once your program run initially you will see that Deno is compiling the index.ts file and printing a random quote from quotes.txt, if you run the programme again without changing the code it will not compile it again and will just show another random quote.
\ndeno run --allow-read index.ts\nCompile file:///C:/Users/PuneetSingh/Documents/deno_fs/index.ts\nPremature optimization is the root of all evil in programming. - Donald Knuth\n\n\ndeno run --allow-read index.ts\nA lot of times, people don't know what they want until you show it to them. - Steve JobsLet's create another TypeScript file write.ts and put the below code in it
\nimport { readLines } from "https://deno.land/std@v0.52.0/io/bufio.ts";\n\nconsole.log('Start typing...');\n\nconst encoder = new TextEncoder();\nawait Deno.writeFile("input.txt", new Uint8Array());\n\n// Listen to stdin input by readLines\nfor await(const line of readLines(Deno.stdin)) {\n const data = encoder.encode(line+"\\n");\n await Deno.writeFile("input.txt", data, {append: true});\n console.log("Wrote the above text in input.txt\\n") \n}In the above code we are using readLines to raed user input line by line, Every time we run the code Deno.writeFile(\"input.txt\", new Uint8Array()) will create an empty input.txt file in the folder.
Then const line of readLines(Deno.stdin) in a loop will wait for the user to input any text, as we will give any input Deno.writeFile with {append: true} is used to append data in input.txt
Let's run the program, Once we run it, whatever text we will give to the program through standard input will be written to input.txt
\ndeno run --allow-write write.ts\n\nStart typing...\nThis is a demo for Deno\nWrote the above text in input.txt\n\nIn this demo, we will write some text in a file\nWrote the above text in input.txtIf you check the input.txt file you will found the content which was given as input
\nThis is a demo for Deno\nIn this demo, we will write some text in a fileNow you know how to read from a text file and how to write in a text file with Deno, You can found the complete source code used in the above blog on our Github Repo
\n","frontmatter":{"title":"Read and Write in a local file with Deno","author":{"id":"Puneet Singh","github":"puneetsingh24","avatar":null},"date":"June 09, 2020","updated_date":null,"tags":["Deno"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.6666666666666667,"src":"/static/051c3d60bd1877dbdbc0c04965cdc4db/2a4de/deno_file_system.png","srcSet":"/static/051c3d60bd1877dbdbc0c04965cdc4db/69585/deno_file_system.png 200w,\n/static/051c3d60bd1877dbdbc0c04965cdc4db/497c6/deno_file_system.png 400w,\n/static/051c3d60bd1877dbdbc0c04965cdc4db/2a4de/deno_file_system.png 600w","sizes":"(max-width: 600px) 100vw, 600px"}}}},"fields":{"authorId":"Puneet Singh","slug":"/engineering/read-and-write-in-a-local-file-with-deno/"}}},{"node":{"id":"f2ea29c9-53de-575c-a263-3909142ca770","html":"In this blog, we’ll be implementing OAuth by Github in a Node.js Application
\nThis tutorial assumes you have:
\nTo implement Github Auth we need to register a new application in Github OAuth Apps.
\nOnce you start the process you will get a form like this.
\nFirst in an empty folder run the below command It essentially just creates the package.json file with all the basic information you will provide. after that, we will install all the dependencies needed in our project Create a file index.js in the root folder of your app and add the following code: Our web server has been set up, now we will add the code related to sending the OAuth request to GitHub using Axios package, at the bottom of the index.js file: Note: The callback URL should be the same as used in the GitHub app configuration. Create an ejs file under path views/pages/index.js, it will render into a nice looking Github authorization page: After it we will create an ejs file under path views/pages/success.js, it will be used to show the user's GitHub information we will get after authorized by Github Note: Here we are also using bootstrap and font-awesome css to make our web pages look good. We have finished building our OAuth authorization page, let's run the application by below command Once our server is running, we can see our social login page on We need to click on the Github Login button, which will redirect us to google login page. You can implement the OAuth in Node.js by the above process, You can found the complete code used in this tutorial on out In this blog, we’ll be implementing OAuth in node js application via Google. For this, we’ll be using Passport.js, an authentication package for Node.js. Here’s a quick guide on implementing OAuth 2.0 in node js. This tutorial assumes you have: We can create a client ID and client secret using its Google API Console. You need to follow below steps once you open Google Auth API Console Note: If Google doesn't support To create OAuth nodejs authentication, first in an empty folder run the below command It essentially just creates the package.json file with all the basic information you will provide. after that, we will install all the dependencies needed in our project Create a file index.js in the root folder of your app and add the following code: Our web server has been set up, now we will add the code related to the passport at the bottom of the index.js file: Now, at last, we are ready to implement Google Authentication in our app, Add the following code at the bottom of your index.js file, use your client Id and Secret instead of placeholders: Note: The callback URL should be the same as used in the google app configuration. Create an ejs file under path views/pages/auth.js, it will render into a nice looking social login page: After it we wll create an ejs file under path views/pages/success.js, it will be used to show the user profile information we will get after authenticated by google Note: Here we are also using bootstrap and font-awesome css to make our web pages look good. We have finished building our social login page, let's run the application by below command Once our server is running, we can see our social login page on 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.Step 2: Initialize a node.js project with all the dependencies
\n
\nnpm init\n
\n
\nnpm install express ejs axios --saveStep 3: Writing express server code to accept web requests
\n
\n// index.js\n\n/* EXPRESS */\nconst express = require('express');\nconst app = express();\n\napp.set('view engine', 'ejs');\nvar access_token = "";\n\napp.get('/', function(req, res) {\n res.render('pages/index',{client_id: clientID});\n});\n\nconst port = process.env.PORT || 2400;\napp.listen(port , () => console.log('App listening on port ' + port));
\n// index.js\n\n// Import the axios library, to make HTTP requests\nconst axios = require('axios')\n// This is the client ID and client secret that you obtained\n// while registering on github app\nconst clientID = 'xxxxxxxxxxxx'\nconst clientSecret = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxx'\n\n// Declare the callback route\napp.get('/github/callback', (req, res) => {\n\n // The req.query object has the query params that were sent to this route.\n const requestToken = req.query.code\n \n axios({\n method: 'post',\n url: `https://github.com/login/oauth/access_token?client_id=${clientID}&client_secret=${clientSecret}&code=${requestToken}`,\n // Set the content type header, so that we get the response in JSON\n headers: {\n accept: 'application/json'\n }\n }).then((response) => {\n access_token = response.data.access_token\n res.redirect('/success');\n })\n})\n\napp.get('/success', function(req, res) {\n\n axios({\n method: 'get',\n url: `https://api.github.com/user`,\n headers: {\n Authorization: 'token ' + access_token\n }\n }).then((response) => {\n res.render('pages/success',{ userData: response.data });\n })\n});Step 4: Creating a Login and Profile page
\n
\n<!-- views/index.ejs -->\n<!doctype html>\n<html>\n<head>\n <title>Github OAuth</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-primary">\n <h1><span class="fa fa-github"></span> Github OAuth</h1>\n <p>Authorize your app with:</p>\n <a href="https://github.com/login/oauth/authorize?client_id=<%= client_id %>" class="btn btn-danger"><span class="fa fa-github"></span> Github Login</a>\n </div>\n</div>\n</body>\n</html>
\n<!-- views/success.ejs -->\n<!doctype html>\n<html>\n <head>\n <title>Github OAuth</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-primary text-center"><span class="fa fa-github"></span> Github Information</h1>\n <div class="row">\n <div class="col-sm-6">\n <div class="well">\n <p>\n <strong>Name</strong>: <%= userData.name %><br>\n <strong>Username</strong>: <%= userData.login %><br>\n <strong>Company</strong>: <%= userData.company %><br>\n <strong>Bio</strong>: <%= userData.bio %>\n </p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </body>\n</html>
\nnode index.jshttp://localhost:2400/Before You Get Started
\n\n
\nStep 1: Create a Google client ID and client secret
\n\n
\nhttp://localhost:3000/auth/google/callbackhttp://localhost:3000, then use http://127.0.0.1:3000Step 2: Initialize a node.js project with all the dependencies
\n
\nnpm init\n
\n
\nnpm install express ejs express-session passport passport-google-oauth --saveStep 3: Writing express server code to accept web requests
\n
\n// index.js\n\n/* EXPRESS */\n\nconst express = require('express');\nconst app = express();\nconst session = require('express-session');\n\napp.set('view engine', 'ejs');\n\napp.use(session({\n resave: false,\n saveUninitialized: true,\n secret: 'SECRET' \n}));\n\napp.get('/', function(req, res) {\n res.render('pages/auth');\n});\n\nconst port = process.env.PORT || 3000;\napp.listen(port , () => console.log('App listening on port ' + port));
\n// index.js\n\n/* PASSPORT SETUP */\n\nconst passport = require('passport');\nvar userProfile;\n\napp.use(passport.initialize());\napp.use(passport.session());\n\napp.set('view engine', 'ejs');\n\napp.get('/success', (req, res) => res.send(userProfile));\napp.get('/error', (req, res) => res.send("error logging in"));\n\npassport.serializeUser(function(user, cb) {\n cb(null, user);\n});\n\npassport.deserializeUser(function(obj, cb) {\n cb(null, obj);\n});
\n// index.js\n\n/* Google AUTH */\n \nconst GoogleStrategy = require('passport-google-oauth').OAuth2Strategy;\nconst GOOGLE_CLIENT_ID = 'our-google-client-id';\nconst GOOGLE_CLIENT_SECRET = 'our-google-client-secret';\npassport.use(new GoogleStrategy({\n clientID: GOOGLE_CLIENT_ID,\n clientSecret: GOOGLE_CLIENT_SECRET,\n callbackURL: "http://localhost:3000/auth/google/callback"\n },\n function(accessToken, refreshToken, profile, done) {\n userProfile=profile;\n return done(null, userProfile);\n }\n));\n \napp.get('/auth/google', \n passport.authenticate('google', { scope : ['profile', 'email'] }));\n \napp.get('/auth/google/callback', \n passport.authenticate('google', { failureRedirect: '/error' }),\n function(req, res) {\n // Successful authentication, redirect success.\n res.redirect('/success');\n });Step 4: Creating a Login and Profile page
\n
\n<!-- views/pages/auth.ejs -->\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">\n <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">\n <style>\n body { padding-top:70px; }\n </style>\n</head>\n<body>\n<div class="container">\n <div class="jumbotron text-center text-primary">\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<!-- views/success.ejs -->\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 bootstrap 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-primary 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>: <%= user.id %><br>\n <strong>Email</strong>: <%= user.emails[0].value %><br>\n <strong>Name</strong>: <%= user.displayName %>\n </p>\n </div>\n </div>\n </div>\n </div>\n </div>\n </body>\n</html>
\nnode index.jshttp://localhost:3000/