Up next in 10
Build a Golang Google OAuth2 Login & Logout System With Sessions in Browser Using Goth Library
Dec 10, 2025
Buy the full source code of the application here:
https://procodestore.com/index.php/product/build-a-golang-oauth2-google-login-logout-system-with-sessions-in-browser-using-goth-library/
Show More Show Less View Video Transcript
0:00
Uh hello friends, today in this tutorial
0:02
I will basically show you uh how to
0:04
build a Google authentication loginout
0:07
system inside Golang. Golang basically
0:10
it's a new language. It's a very popular
0:12
language used nowadays. So I will show
0:15
you how to implement this Google
0:16
authentication system ooth 2. So I have
0:20
this log out function. We have the
0:22
profile picture ID, email name. All this
0:25
profile information of the user would be
0:27
shown in the profile information route
0:28
here. right here. So now we have this
0:30
log out button. So if I click this log
0:32
out button right here, I will be
0:34
redirect to the homepage. So let me run
0:37
the file here by using go run main.go.
0:40
It will compile this and it will start
0:42
the server on localhost 3000. And
0:45
basically you will see that you will be
0:47
redirected to the homepage right here.
0:49
And we have actually this sign in with
0:51
Google button right here. So this is the
0:53
actual button. So as I click the button
0:55
right here authentication flow will
0:58
start and you basically need to here it
1:01
will tell you that you need to paste
1:04
your oath client ID and client secret.
1:08
So first of all in order to build this
1:10
you just need to go to Google cloud
1:12
console and uh you need to create an
1:14
account here free account just create a
1:17
free account right here and just go to
1:19
APIs and services and uh right here we
1:25
need to go to credentials and uh after
1:28
that we need to click on plus create
1:31
credentials and click on oath client ID.
1:35
I will just show show you this process
1:37
in detail when we we develop this
1:39
application. So I've already uh just
1:42
created one client ID which is this one.
1:45
So what I will do is that I will just
1:47
copy this.
1:49
If I go to this file which is main.go
1:51
file. So I already you will see you need
1:54
to paste this client ID client secret
1:57
here. Client ID client secret. So let me
1:59
just do it automatically. I've already
2:02
copy pasted it. So if I just now refresh
2:05
this, click on this button. So you will
2:07
basically see that you need to restart
2:09
your server. Every time you make the
2:11
change guys, you need to run this go
2:13
runb main.go file. So onceever you uh
2:17
make any sort of changes inside your go
2:19
file. So now if I click this button,
2:22
you'll basically see it will actually
2:25
tell me the profile information. You
2:27
will see that. So
2:30
so you will see that. So,
2:34
[snorts] so basically if I refresh the
2:37
page here, if I go to localhost 3000
2:40
once again, that information is saved
2:42
right here in the session variables. So,
2:45
whenever I try to let's suppose I close
2:47
this window and try to open it once
2:49
again, go to localhost 3000, you will
2:52
basically see it will show you this
2:54
profile information. So, basically all
2:57
this information is saved inside the
2:59
session variable. Uh if you also close
3:02
this browser and open a new browser
3:03
window let's suppose I open new
3:05
incognito window just go to localhost
3:08
3000 that session will not be saved
3:12
because that session will be saved only
3:15
in that current browser window. So once
3:18
again you need to go to that
3:20
authentication flow. You need to just
3:23
enter your email information, password
3:25
information. It will ask here. So you
3:27
just need to do this. So if I open new
3:31
window right here, if I just type
3:33
localhost 3000,
3:36
you will see. So once again, it will
3:38
show you this uh uh profile information
3:42
log out button. So if you just open
3:44
incognito window where you haven't
3:47
logged in inside your Gmail account,
3:49
then it will ask for the information.
3:51
But if you are successfully logged in
3:53
inside in this account, you will see I'm
3:55
currently logged in inside my Gmail
3:57
account. So that's why it is not asking
3:58
me once again. So as I click the log out
4:01
button now, so if I now try to basically
4:04
go to the same URL localhost 3000, then
4:07
it will basically ask for sign in with
4:09
Google. So we are implementing this log
4:12
out and login uh authentication. So I
4:16
will now show you how to do this
4:18
process, how to build this from scratch.
4:21
So all the source code I have given guys
4:23
in the description of the video. You can
4:24
purchase it from PayPal in United State
4:28
dollar or stripe in Indian rupees. So
4:29
both the payment links are given in the
4:31
description of the video. So this is
4:34
basically the final structure of the
4:35
application and after you purchase it
4:38
you will actually get basically this uh
4:40
uh zip file compressed zip file you will
4:44
get. So you just need to extract the
4:45
content of this zip file. So after you
4:48
do this you will basically get the
4:50
source code. So now let me just start
4:53
building it from scratch. So we have
4:55
this templates folder. Let me delete
4:57
this also. And this is our main go file.
5:01
And uh now I will simply include package
5:05
main.
5:09
And then we need to import some
5:10
dependencies right here guys. FMT in
5:14
order to
5:17
console lock some messages on the
5:18
screen. Then we have HTML/
5:22
template. So this will be used to
5:24
actually show the uh template of the
5:28
user which is HTML template. Then we
5:30
will need the HTTP module. Then we will
5:33
need the log module.
5:35
And then we are using these three third
5:38
party dependencies which is used to
5:40
implement uh OOTH2 authentication which
5:44
is gorilla/pacted.
5:46
This is the first package. The second
5:48
package we are using is github.com/mark
5:53
bait
5:55
goth go. This is the actual name of the
5:58
library. If you see guys basically it's
6:00
a authentication library for Golang. If
6:03
you just type goth Golang it this is
6:07
actually the GitHub repository for
6:10
implementing various authentication
6:11
system. It does it it supports all these
6:14
social media networks GitHub, Google,
6:17
Google+, Heroku. So all these social
6:19
media networks are supported. So in this
6:22
specific video we are talking about
6:23
Google and uh then we will say GitHub/
6:30
from the same package marks
6:33
go/thic
6:39
then github/.com/mark
6:46
baits/
6:48
goth and we have various provider ers.
6:51
So in this specific video we are talking
6:54
about the Google provider
6:56
github.com
6:59
gorilla/
7:01
sessions. So it also includes a session
7:03
library as well guys which allows you to
7:06
save the information in the session
7:08
whenever you are successfully logged in.
7:10
And now we will basically create a store
7:12
variable
7:15
and this will be a cookie store where we
7:18
will store all the user information in a
7:20
cookie or a session and here we need to
7:22
initialize our session guys in a in init
7:25
function. So in inside Golang guys this
7:27
init function is used to function is
7:30
declared like this in Golang function
7:33
like this. This is the way by which if a
7:37
function is declared and here we just
7:38
need to declare a key variable this can
7:41
be any value you can give you can give
7:44
my secret key and uh this is a session
7:47
secret key that you are giving and
7:48
maximum age of the session how many time
7:52
you need to save the information so I
7:54
need to save this information
7:56
let's suppose this value is in second so
7:59
we are basically multiplied by 30 days
8:02
this simply means that we
8:04
storing user info in cookie for 30 days.
8:11
So in each day this much of seconds are
8:14
there we are multiplying it by 30. So we
8:16
are basically declaring it. So after
8:19
this we will say is production.
8:23
So if you're developing it for
8:24
production make it to true but we are
8:26
just inside our development environment.
8:29
So we will simply say false. So now
8:32
after that we will basically declare our
8:35
store which is sessions dot new cookie
8:39
store and here we will actually
8:42
basically have a byte
8:47
key. So key variable that we have
8:49
declared guys you will see we are simply
8:51
using it and we have declared our store
8:54
and now we need to store the maximum age
8:56
of it. So we will pass the maximum age
8:58
that we have declared and the options
9:01
which is HTTP only to true. So we are
9:05
not using HTTPS. So we are simply using
9:07
HTTP only. And then store dot options
9:10
dot seccure and secure is equal
9:13
dependent upon the production value. So
9:15
if you're developing for production then
9:17
it will be HTTPS. So if you're not
9:19
developing for production then it will
9:22
be HTTP.
9:24
And then lastly Gothic. Gothic dot store
9:30
is equal to the store that we have
9:31
declared. That's all. So this
9:33
initialization function guys will
9:34
actually initialize your uh cookie that
9:37
we have declared this cookie store. And
9:41
now after this we will actually write
9:42
our main function of our Golang. And
9:46
inside this we will basically declare
9:50
use providers. So which provider we are
9:52
using. So we are basically using the
9:54
Google provider that we have. So Google
9:56
do new and here we need to paste our
9:59
client ID and client secret. So just go
10:02
to your development console and whatever
10:06
let's suppose in which port number you
10:08
are having this application. So in this
10:12
I will try a different port. Let's
10:13
suppose I start my application on
10:15
localhost 4,000. So what I will do is
10:18
that I will simply you need to go to
10:20
credentials and click on create
10:22
credentials o client ID. So this option
10:25
you need to select and from the
10:27
drop-down we are developing a web
10:29
application simply select web
10:30
application and in the authorized
10:32
JavaScript origins you just need to give
10:34
the URL which is HTTP localhost 4,000.
10:39
So this will be the port number that we
10:41
will be using for this application. This
10:43
will be the home URL and then the
10:46
redirect URI. You need to give this URI.
10:50
You can give any URI but this is the URI
10:53
that I will use which is localhost
10:55
4000/google/allback.
11:00
This is the URL that we will use guys in
11:03
this tutorial.
11:05
/g Google/allback. And now click create.
11:09
And after that it will give you these
11:11
two information which is client ID and
11:12
client secret. Simply copy this and just
11:16
create your own client ID guys. So don't
11:18
copy my client ID. I will simply delete
11:20
this after I publish this video.
11:26
And inside our client secret. So simply
11:28
paste this also as a sec second
11:30
argument.
11:33
Uh after that guys we will actually have
11:36
our third argument which is our redirect
11:39
URI. Same redirect URI we will use
11:42
4,000/google/
11:46
callback.
11:49
And then the fourth one will be the
11:51
scopes. So whichever information that
11:53
you want to access from the Google login
11:55
we need to access the email of the user
11:57
and the profile information. That's all.
11:59
So this you need to write in a single
12:01
line. So just do it like this. So we are
12:04
basically providing the redirect URI and
12:06
then the scopes. We are requesting the
12:09
email of the user and the profile
12:10
information of the user and just put a
12:12
comma right here.
12:18
That's all. So after you declared this
12:20
guys, we just need to say P
12:23
colon is equal to we will declare a new
12:25
variable which is pat dot new
12:30
and p do.get get
12:36
uh basically we will say or slash. So
12:39
first of all here guys we actually are
12:42
declaring this p variable. This simply
12:44
means that we are declaring this to
12:46
initialize routes inside our golang
12:49
application to initialize routes. So how
12:52
to do this? We will basically first of
12:54
all write our get route whenever we open
12:58
the homepage. So p do.get get. So
13:02
whenever we open the homepage what we
13:04
need to do we need to say response http
13:08
we have included this module. So this
13:10
contains this response writer
13:13
and request
13:19
this is request here
13:24
http dot request.
13:27
So this basically it's a simple routing
13:29
that we are doing right here.
13:33
This is
13:36
the session
13:39
underscore.
13:41
So all the source code is given guys. If
13:43
you have any problem in
13:47
you can basically purchase it. So link
13:49
is given store dot and then we will get
13:53
this session by its name. So we will say
13:56
request slash comma and this is a
14:00
session name that I will give which is
14:01
Google login. You can give any name of
14:03
your choice
14:05
and then we will actually have our
14:11
so this is the thing guys. Let me paste
14:14
it here.
14:15
Slightly complicated this one. So this
14:18
is the actual thing. If you see
14:24
we just need to close this curly
14:27
bracket.
14:30
[snorts] So
14:32
uh
14:35
this also just
14:40
let me just
14:42
write this first of all
14:49
copy
14:52
go lang is slightly complicated to write
14:54
guys it's not similar to Python with
14:57
JavaScript
14:58
so what's what What I will do is that I
15:01
will show you how I did it. So,
15:07
so basically this is our get route guys.
15:09
You will see we are actually using the
15:11
get route. We are having the home route
15:13
which is slash and then we have this uh
15:16
http response similar to nodejs.
15:18
Whenever we go to this uh home route, we
15:21
have session here.
15:26
And what I will do is that here we will
15:29
get
15:30
the current logged in user in the
15:32
session. If the session is available in
15:34
the this store, we will use store.tget.
15:39
And this is the name of the session that
15:40
I will give which is Google login.
15:44
We will simply check here if the user is
15:46
available in the session then we will
15:49
actually show the profile. If it is not
15:52
available then in that case we will show
15:54
the session dot values
15:58
and this will be user.
16:02
This needs to become in the double
16:04
quotes. Sorry.
16:09
So here we will use the okay value. If
16:12
it's true then in that case
16:18
we will simply say template dot parse
16:21
file. So we will show this template by
16:23
using this template method with template
16:25
dot we'll create [snorts] a templates
16:27
folder in the root directory. So in this
16:31
templates we would use the success html
16:36
t dot execute
16:39
response dot user. We will pass the user
16:41
right here and then we will return. If
16:44
the user is available in that case we
16:46
will show the success template. If the
16:47
user is not available in that case we
16:50
will say that uh
16:53
the user is not available in that case
16:55
we will show the
16:57
login page. So this template/index
17:02
html. So now we need to create these two
17:04
files t.execute
17:06
response.nil
17:10
like this. So after this we just need to
17:14
start we need to print a statement
17:16
printing listening
17:20
on localhost
17:21
3,000 sorry 4,000 I think
17:25
log dot fatal these are simply log
17:28
statements http
17:31
and we can basically listen dot listen
17:33
and serve and here we can change the
17:35
port number to let's suppose 4,000
17:39
and start our application. So second
17:42
parameter is P. That's all. So if you
17:44
now try to compile your Golang
17:46
application and uh also create a
17:49
templates folder
17:51
and just create index.html file.
17:56
This is your
17:59
hello world. Let me set and let me try
18:03
to run this file.
18:10
go run main.go. This is the actual
18:13
command. If you see it will compile this
18:15
code.
18:17
[snorts] So it is saying that
18:29
I think I made a mistake here in
18:31
importing the packages. So what I will
18:33
so simply import copy this
18:37
paste
18:44
So,
18:48
so what I will you will see FMT imported
18:51
and not used. So, I will simply delete
18:54
this. So, this is a problem in Golang
18:56
guys. You need to use all these modules
18:58
that you import. You can't
19:02
you will it will ask for the permission.
19:04
Simply click allow. It will now
19:06
listening on 4,000. If you see guys, you
19:08
will see that.
19:11
So if you basically go to this
19:13
application localhost 4,000, you will
19:16
see a hello world message.
19:22
It is saying that uh run invalid memory
19:25
address pointer D reference
19:41
uh
19:44
sorry guys I made a mistake right here.
19:46
We need to declare this P dot
19:53
I think I forgot to declare P is equal
19:56
to ppad dot new
19:58
P do.get
20:03
function.
20:18
We paste it and change the port number
20:20
let's suppose to
20:23
4,000
20:31
session.
20:35
Let me delete this.
20:58
So let me rerun this application. Uh I
21:01
think some typing mistake was there.
21:08
So it is saying listening on localhost
21:10
4,000. If I try to
21:18
it is returning empty response. Let me
21:20
see.
21:27
Uh I think guys Golang
21:31
if you type a Golang only executes
21:35
at port number 3000. I think there is
21:37
some kind of
21:46
I think there is some kind of problem.
21:47
You can't run on different ports. You
21:49
just need to run on local host 30,000
21:52
only. So this is I think a thing in
21:55
Golang. So just change it to 30,000
21:58
only. So allow the permission and
22:22
uh but I'm making a very silly mistake
22:26
guys here. Uh I don't know which mistake
22:29
I'm making.
22:32
So for the sake of this tutorial, I will
22:34
simply copy this code. You can basically
22:36
get the source code
22:39
by purchasing it guys. So this is the
22:42
source code. And if I try to run this
22:45
now
22:59
session variable
23:06
session.
23:16
So simply allow the permission and uh
23:23
it is going
23:25
host 3000.
23:33
I think uh I missing this success html
23:36
as well. So simply also create this also
23:38
success html.
23:41
I think I'm referencing this file
23:43
success.html. That's why it is creating
23:45
this problem.
23:52
Paste it.
23:56
And now you can see so I was referencing
23:58
this success. HTML file guys. If you see
24:01
in the main.go file if you simply check
24:04
right here if the session is present in
24:08
that case
24:10
open this file success. HTML in the
24:13
that's why it was creating a problem.
24:15
Now if I change the port number to 4,000
24:17
if you see
24:20
and uh let's suppose
24:23
I delete all that and
24:32
I think and restart the application.
24:40
Allow this permission. And
24:52
now you can see that. So we need to
24:55
click the log out button.
25:00
So already some things are stored inside
25:03
this session variable. If you see, so it
25:07
is saying that.
25:12
So what we need to paste right here our
25:15
client ID and the client secret.
25:18
So this information that we got, we just
25:22
need to paste. Copy
25:25
the client ID.
25:30
Copy the client secret. Just paste this
25:33
information right here
25:38
and just change it to 4,000 redirect
25:41
URL.
25:43
And now inside this index html guys
25:46
there will be a simple login form
25:47
basically where the user will click. So
25:50
we are also using bulma CSS which is a
25:53
very popular CSS framework. Just include
25:56
the CDN for this CSS part.
26:00
And uh this is
26:05
inside this we are having a div
26:08
container
26:10
jumbotron
26:12
text center text access.
26:24
And here you are having FA FA lock
26:32
social authentication.
26:45
So we have a HF which will go to /
26:49
Google and uh
26:52
we will have a button btn btn danger and
26:55
uh
26:58
we will have a icon right here which is
27:01
we will give it f a fa google. says the
27:04
icon for Google and we will simply say
27:06
right here
27:08
sign in with Google.
27:16
[snorts] So now we just need to make
27:17
this request guys. It will redirect the
27:19
user to this / google. And now inside
27:22
our main go file uh we need to write
27:25
this route. So this route will be this
27:29
route. If you see p dot get and uh this
27:34
will be slash slash
27:39
sl /
27:41
this is a dynamic provider that we are
27:43
adding. So this needs to go in double
27:45
quotes.
27:50
So whatever is the provider it can be
27:52
either Google, Facebook, anything we are
27:55
talking about face sorry Google in this
27:57
case. So response
27:59
httpreson
28:01
writer.
28:11
There is not a comma right here. And
28:16
request dot
28:19
http
28:21
dot request
28:28
And here we will say gothic
28:31
dot
28:33
begin
28:36
o handler.
28:38
This is a function inside this library
28:41
response request.
29:01
So if you just try to run this now just
29:04
refresh this application and uh
29:10
go to this localhost 4,000
29:17
and let me just uh delete this
29:21
we are only having this information
29:28
let me delete this so we are only
29:30
loading this index html for now because
29:34
we haven't saved any user information so
29:36
just delete that for a second and if you
29:39
start this now it will allow the
29:41
permission and uh refresh you will
29:43
basically see sign in with Google if you
29:46
press this now you will be redirected to
29:47
your uh user
29:49
You can select your account. This is my
29:51
account coming. You can see coding
29:53
section. If I'll select this account and
29:55
I just need to grant the access right
29:57
here. And you will basically see this
29:59
will be coming right here which is ooth
30:02
client ID. We are passing this. So for
30:05
this we need to add another request guys
30:08
which will be responsible for handling
30:11
this.
30:14
So
30:15
this is a redirect URI.
30:19
we need to add.
30:23
So whenever you do this, we also need to
30:25
add this. So whenever this
30:27
authentication flow starts, in order to
30:29
get the access token, we need to write
30:31
this /
30:34
which is the provider in this case is
30:36
Google. It will be dynamically passed
30:38
and then the callback.
30:43
[snorts] This is the same guys that we
30:44
passed right here. If you see /g Google/
30:50
callback and we are basically writing
30:51
this request. This request will take
30:54
care of getting the access token and all
30:56
that stuff.
30:59
Now let me write this uh
31:08
just need to import that fmt module.
31:15
So in this we are basically completing
31:17
the user o we are getting this
31:18
information and saving this information
31:20
inside our session variable which is
31:22
google session and basically sewing the
31:25
success html.
31:28
So if you just refresh now,
31:32
allow this.
31:44
Click on sign in with Google and you
31:46
will see you will be redirected to show
31:49
this information which is this one.
31:53
And [snorts] how we are showing this
31:55
information? If you see basically we
31:57
have this uh if I
32:06
if I make this changes and refresh I
32:09
think it will refresh
32:11
local host 4,000.
32:17
So nothing will be there. Profile
32:18
picture ID, email, login name, we are
32:21
having this. And now for the profile
32:22
picture, we have the image tag. And this
32:25
is present inside avatar, URL. This is
32:28
the actual thing. And for the name, user
32:32
ID, we are basically saying here user ID
32:39
and for the email we are simply saying
32:41
email
32:43
and for the name dot name. So we are
32:45
basically showing this information.
32:47
Avatar URL, user ID, email name. If you
32:51
just refresh now
32:54
you will see that. So this is your
32:56
profile picture ID, email name and this
33:00
is our log out button. So if you see in
33:02
the log out button we are basically
33:04
making this request / logout/google.
33:08
So we just need to make this inside our
33:11
Golang. We need to define a route which
33:14
will handle the logout process. P.get/
33:18
logout
33:22
slash provider which is Google in this
33:25
case slash sorry that's all.
33:45
So inside this request we will actually
33:48
delete information from session
33:53
first of all. So session if the session
33:56
information exist we will first of all
33:58
get the store store.get we will get this
34:01
information from the user store.get get
34:05
request and the name of the session that
34:07
we declared which is Google login. We
34:10
just need to write this. After that
34:16
in order to delete this we have the
34:17
delete function in the delete session
34:21
drop values and user delete this user
34:24
session and session again save
34:29
request response and then we have this
34:31
gothic and it has a logout button
34:35
pre-built. We will say response request
34:39
and then we will set the header in order
34:42
to redirect the user to the homepage
34:47
location
34:49
that's all response.right Right header
34:54
http dot status
34:58
uh temporary redirect. We will redirect
35:01
the user
35:11
that's so we redirect the user to the
35:13
homepage. You will see that. So
35:16
[snorts]
35:18
and now
35:21
you just you will see it will also print
35:23
out this information in the say JSON
35:26
response all this information coding
35:28
section ID this is a profile information
35:31
description all this things so we
35:33
displaying this information in the
35:34
browser So,
35:45
so
35:47
if I click log out, I will be redirected
35:49
back to the homepage. So, I just want to
35:53
do guys one thing. I just need to
35:56
make sure that if I stay on the same
35:59
page, I need to simply detect the user
36:03
that the user is currently logged in. We
36:05
need to show this information. So for
36:07
that we will add a route here. Add a
36:10
condition inside our whenever we go to
36:13
the homepage we need to get the session
36:14
variable. So this we can add this once
36:18
again
36:21
the earlier code.
36:24
So this code will actually get the
36:26
session variable whenever we go to the
36:29
homepage. If the user is currently
36:31
logged in we will get the information
36:33
and basically show the profile of the
36:36
user by passing this information. If the
36:38
user is not found in that case we will
36:40
show the login page. This is a complete
36:42
application guys. And if I
36:48
you will see uh we also need to include
36:50
our pelma CSS
36:54
CSS also. So I will simply paste that
36:56
also.
36:59
Just need to restart.
37:09
Click on log out. And now you will see
37:11
that you can do this for any account
37:13
guys. Let's suppose I have a different
37:15
account here. If I go to this local host
37:18
4,000
37:21
and uh I need to go to the same process.
37:24
I will select my account here. You will
37:26
see that I need to grant permission. And
37:28
now you can see that. So it will
37:29
basically show my profile picture now.
37:32
Name here you will see that email
37:34
address you will see that and log out.
37:37
If I go to the basically stay on the
37:39
same page,
37:44
it will redirect. You can see if I stay
37:45
on the same page,
37:51
you can see that it will stay on the
37:53
same page. It has detected that I am
37:55
currently logged in. So as I click the
37:57
log out button now, you will now see if
37:59
I refresh now, I will be redirected back
38:02
to the homepage. So in this case guys we
38:05
have developed a simple login logout
38:07
oath Google system in Golang and you can
38:11
do this for any application it doesn't
38:13
depend you will see
38:16
so this is the thing guys and if you
38:18
like this tutorial please hit that like
38:20
button all the source code is given if
38:22
you have any problem full directory
38:25
structure I have given the source code
38:27
uh you will not face any problem you
38:29
just need to replace your client ID
38:30
client secret that's all from Google
38:33
developer console and uh this is the zip
38:36
file that you will get after you make
38:37
the payment from Google Drive and uh
38:42
all the source code is given. You can
38:43
purchase it from PayPal in United State
38:45
dollar or stripe in Indian rupees. So
38:47
both the links are given. So thank you
38:49
very much guys. Please comment on this
38:51
video. Please hit that like button and I
38:53
will be seeing you in the next video.