Pratique du Shadowing: Build a Microservice with Go #1 - Getting Started - Apprendre l'anglais à l'oral avec la vidéo

Choisissez un mode d'entraînement

Chaque mode ouvre une salle d'entraînement en plein écran.

204 phrases

Si les phrases sont trop courtes ou trop longues, cliquez sur Edit pour les ajuster.

All right then gang, so in this series you're going to learn how to make a microservice with Go

and a framework called Qi or Kai or however else you want to pronounce it.

And to teach you how to do this I've brought in

the YouTuber Dreams of Code who's got a bunch of really nice videos about Go, Python, Rust and other subjects as well.

His videos are all really slick and informative so definitely check out his channel.

The link is down below the video.

Anyway without further ado So let the tutorial begin.

Go is a modern programming language that prides itself on being simple to use whilst remaining powerful and performant.

Because of this, Go is a language that is popular for building many different types of software, such as command line tools, network applications and microservices.

In this series, we're going to walk through building an API microservice in Go from start to finish.

By the end, you'll learn how to spin up a basic microservice API, which connects to a Redis database and is responsible for creating, reading, updating and deleting our data type.

So without further ado, let's get started.

Before we can begin writing code, we'll need to make sure we have Go installed on our system.

I'll be using macOS for the majority of this video, but it should be similar in other operating systems as well.

If you head on over to the Golang website, you should be able to find installation instructions for your operating system.

If you're okay with a basic installation, I recommend following the instructions found here.

For me however, I'm going to use a tool called Goenv, which allows us to manage multiple versions of Go on the same system.

So I'm going to show you how to get that set up.

To install Goenv, you can either follow the instructions on GitHub or use your operating systems package manager, if you have one of course.

For macOS, it's as simple as using brew install goenv.

Once Goenv is installed, run the following line to ensure that it loads every time your terminal starts, and then restart your terminal window.

You can test that everything is working okay with the following command.

If this doesn't work, then you may have missed a step.

With everything set up, we're now ready to install Go.

What's nice about using Goenv is that you're able to install the same version as I am in this tutorial, as it's very likely that a more recent version of Go is currently available at the time you're watching this.

You're probably okay to use the latest version of Go as the developers try hard to remain backwards compatible.

However, there's never a guarantee of that being the case.

So feel free to use the same version as I am in the video if the most recent one doesn't work.

To install Go, type in the following command.

This will install version 1.20.5.

After that, we can run the following command to set the global version of Go in Goenv.

Finally, you can test that everything is working correctly by running the go version command, which should print out 1.20.5.

Now we're ready to start building.

By the way, in case you haven't noticed, I pretty much use the terminal for most of my development.

I also use NeoVim as my editor of choice, but you may feel more comfortable using something like VS Code or another graphical editor.

The CLI commands that I use in this video should work the same for you, however, and so you may need to jump into the terminal at certain points.

First things first, we'll need a directory to store our project.

I'm going to create mine under projects slash orders API.

Feel free to choose a different directory for yourself however.

Once inside we now need to actually initialize our go project.

We can do this by running go mod init.

You'll need to add the project repo as the final argument.

This can be any git repo, such as github or gitlab.

Here I'm specifying my github repository.

Additionally this repo doesn't need to exist at this stage, you can always create it later and you can always rename this if you need to.

GoMod is basically Go's dependency management solution, similar to Node's npm or Ruby's gems.

However, unlike those systems, it's actually decentralized and works off of git, and therefore each Go project is specified by the git repo it relates to.

After running GoMod in it, you should see a go.mod file inside of your project.

If we open this up, we can actually see that this has our project repo inside of it.

Simple stuff.

Next, it's a good idea to initialize Git so

that we can actually have good hygiene on our project and track changes as we go through.

So, just run the git init command to initialize our repository.

After that, go ahead and add our initial commit, which should just be our GoMod.

Once that's done, open up your project in your editor, and let's start our first file.

Let's call this main.go to specify this is where the main function will live.

The first line you want to add is the package name, in this case it's the main package.

Every file in Go belongs to a package, which is how imports are organised.

In this case we're specifying that the main.go file lives in the main package, which tells the compiler that our code is a program and so it builds an executable.

Next we need to add our main function.

Every Go program has a main function, which acts as the main entry point to our code.

As is customary, let's start off by printing hello world inside of our main function.

To do this we first need to import another package, called fmt, or format.

Some others might call it phmt, but I disagree.

To do this we need to call the import format command just underneath our main package.

If you have a modern editor configured properly, imports should be automatically imported for you, but it's worthwhile us doing this manually just to see how this works.

Next head back to the main function and type in format.println .

You'll notice that this function is camelCase but the first letter is a capital.

Go uses this for encapsulation to specify that the function is public.

Now our program is complete.

Let's jump over to a terminal window and actually run this code.

We can do so by using go, run, and to the name of our file path.

In this case, main.go.

After a short period of time, you should see Hello World print to the console.

Perfect.

We've just created our first Go program.

Congratulations.

We can also build our code by using the go build command, converting it into a binary.

Go is pretty awesome and you can build binaries for other architectures if you like.

However, that's beyond the scope of this video.

Now that we have the basics down, let's turn it up and actually build a simple web server, which we'll use as the starting point for our API.

Go comes with a rich standard library and provides all we need to get a basic web server running, which we can extend later on.

To start, first add the net slash HTTP package to our imports.

This package provides functionality for creating both HTTP clients and servers, which is what we want.

Now we can instantiate an HTTP server using the following line in our main function.

This creates a basic go type of HTTP server and stores it in a variable called server.

You'll notice we're using an ampersand, which means we're storing this as a pointer and taking the memory address, rather than the value.

this type we can then define some of the properties of our server.

The first is the server's address, which will bind to port 3000 using the given string.

Next we'll need to specify a handler for our server.

This is an interface that will be called when our server receives a request.

Let's use the http handler function call and specify a function named basic handler, which we're going to create now.

To do so let's define a new function using the func keyword.

We'll call this basic handler as we suggested and specify the following parameters, which is what we need for our function to be able to conform to their HTTP handler interface.

The first parameter is called w and is a HTTP response writer.

This is an interface type that enables us to write what will eventually be our HTTP response.

The second type is called r and is a pointer of type HTTP request.

We can tell this is a pointer by the use of the asterisks.

This type represents the inbound HTTP request the server receives from the client.

100

Inside of the function let's go ahead and write a body response of hello world.

101

We can do this by calling the write method of the response writer.

102

This function expects a byte array so we'll need to cast our string to be one, which is done by using the syntax on screen.

103

All that remains is to actually run our server.

104

We can do this by calling the listen and serve method on our server type.

105

This method returns an error and it's good practice in Go to handle them.

106

This is done by using an if error check, which will check if the error exists, i.e. it's not nil.

107

Inside of the block we can then handle the error, which in our case we're just going to log it to stdout using the format.println method.

108

Okay, now we're able to go ahead and test out this code.

109

Let's jump over to a new terminal window.

110

We can run our app using the go run command we saw earlier.

111

Once that's done we can open up another terminal window and run a curl command to our localhost at port 3000.

112

This will send an HTTP GET request to our server.

113

And we can see we get a response of hello world which shows us our server is working as expected.

114

Very nice.

115

To stop the the server, head over to the window where we're running it and press Ctrl and C.

116

Now that we have our basic web server up, it's time to add some additional functionality to it.

117

The first thing we're going to want to do is handle HTTP routing.

118

You may have noticed but we currently only have a single handler in our project, which will handle all of the inbound requests.

119

We could do some basic routing inside of this handler, but that can be incredibly tedious to do so, and it's a challenge to properly handle things such as path parameters.

120

So whilst Go does have a robust standard library, it's worthwhile for us to use a third-party dependency at this point.

121

But which one?

122

Well, my go-to router used to be GorillaMux, which offered a great deal of functionality for very little abstraction,

123

whilst remaining true to the HTTP handler interface of the standard library.

124

However, as of the end of 2022, GorillaMux has been archived as read-only, So for future proofing our API, it's probably not the best choice.

125

There's plenty of other options out there however, but for this video I'm going to go with Qi.

126

This router is very similar to GorillaMarks and also conforms to the http interface of the standard library, so it works as a suitable replacement in my opinion.

127

To use Qi we first need to add it to our code.

128

There's a couple of ways to do this and they all involve using GoMod.

129

Before I show you these approaches, now is a good time to commit our code so we can easily roll back any changes.

130

If we run git status we can see that our API binary currently appears in the untracked files.

131

That's not ideal.

132

When using git it's a bad practice to commit any build

133

artifacts as they can add junk to a git repo pretty quickly.

134

To solve this we need to add a .gitignore.

135

Let's go ahead and create one.

136

Inside we can then specify the name of any file or folders we want git to, well, ignore.

137

Let's add the name of our binary, which is API.

138

Okay great, now if we run git status again we should see that the API is no longer available to be tracked.

139

Also because we're on macOS it's probably worthwhile to also add the .ds store files to our git ignore as well.

140

These files are created whenever you navigate to a directory using finder.

141

Rather than opening up our .git ignore file again, we can actually run the following command, which will concatenate a string into our .gitignore file.

142

Once that's done, go ahead and run the git add command to add all of the files in our directory, and then run the git commit command to store them.

143

Now we can demonstrate the two approaches for adding a dependency to our project.

144

The first approach is to use the go get command, which will download and add an entry to the go mod of our current go project, provided we're in one.

145

Let's try this by adding chi to our project.

146

To do so, type in the following command.

147

You'll notice that we're specifying the git repo of qi.

148

Remember, GoMod is decentralized, and so it uses the git repo URL as the package identifier.

149

Now if we take a look at our go.mod, we can see that an entry has been added.

150

So this is the first approach.

151

However, the second approach tends to be the one I use more often.

152

Let's reset our changes to show how we would use this use this.

153

For this approach, we just import the package into our code like we would any other.

154

Then when we want to add it to our GoMod, we just call GoMod tidy in our terminal.

155

This will tell Go to search for any packages within our project and add them to the Go.mod.

156

As you can see, Qi has now been added.

157

Also, you may have noticed that a Go.sum file now exists as well.

158

This is used to ensure consistency across package versions in case they are updated upstream.

159

It's a good idea to check in both the GoMod and the Go.sum files into our our Git repo, so we'll do this now.

160

Okay, with Qi added to our project and our code committed, let's actually use it with our HTTP server.

161

Heading back to our main function, we need to first initialise a new instance of the Qi router for use with our server.

162

We can do this by calling Qi.newRouter and assigning it to a variable called router.

163

In Go, any method prefix with the word new is conventionally a constructor.

164

Oftentimes it's preferable to use the constructor method instead of directly instantiating an instance, as they will often initialise private properties of the type.

165

With our new router created, let's go ahead and add a root for get slash hello, and we'll match it to the basic handler that we've already got defined.

166

We can do this by calling the router.get method and passing in our path as the first parameter.

167

The second parameter requires an http.handler function, which we can just set to our basic handler.

168

The last thing we need to do is add our router to the server handler.

169

What's really nice about Qi is that the router type itself conforms to the HTTP handler interface, so all we have to do here is replace our handler with our router instead.

170

With that done, we can go ahead and test our behaviour.

171

To do so, let's rerun our app using gorun on our main.go file.

172

Heading over to another terminal window, we can then run our curl command against our localhost at port 3000.

173

However this time you'll notice we get a 404 page not found response.

174

That's because we haven't set any handlers for the slash root, and she is automatically handling that for us, which is pretty neat.

175

Let's run curl again, but this time point it to our slash hello path.

176

This time we get back the expected hello world response.

177

There's one last thing for us to test.

178

Let's try this with a POST request instead of a GET request.

179

We can do this with curl using the X flag, which allows us to specify the HTTP method.

180

Make sure you set X to uppercase.

181

We'll also add the lowercase v flag so that we're able to see the full HTTP headers.

182

Here you can see we're getting an HTTP status response of 405, which stands for Method Not Allowed.

183

This is because we only specified a route for the method of GET in our path, and therefore Qi provides this error for us.

184

With a basic router added, it's clear we're missing something.

185

And that something is logging.

186

Qi fortunately provides us a logging middleware that we're able to use right out of the box.

187

We can add this to our router by first importing the middleware package from the Qi plugin by using the following line.

188

With our middleware imported we can then add it to the router via the use method.

189

Now if we restart our server, we should start to see logs appear whenever we handle a request and response.

190

Nice.

191

Now that we're in a good spot, it's time to commit our code again.

192

To do so, go ahead and run the git add command to stage our changes, and then type in the git commit command to go ahead and commit them.

193

By the way, the M flag stands for message, in case you hadn't guessed that already.

194

This allows us to specify the message we want to store along with our actual commit.

195

By the way, if you want to watch this entire course now without YouTube adverts, you can do.

196

It's all up on the NetNinja website, netninja.dev.

197

You can buy the course for $2 to get instant access to all of it, or you can sign up to NetNinja Pro and get instant access to all of my courses without adverts,

198

as well as premium courses not found on YouTube including my Udemy ones that's nine dollars a month

199

and you can get your first month half price

200

when you use this promo code right here

201

so I'm going to leave this link down below in the video description for you to sign up

202

and I really hope you enjoy this series

203

and please do not forget to share subscribe and like the videos

204

that really helps a lot and I'm going to see you in the very next lesson

Télécharger l'application

Tout pour parler couramment

Prononciation IAChaque phrase notée

Phonétique (IPA)Maîtrisez chaque son

VocabulaireEnrichissez votre lexique

Jeu de vocabulaireApprenez en jouant

Scanner le QR

Download on theApp Store Get it onGoogle Play

Même chaîne

Spec Driven Workflow with Claude Code #1 - Making a /spec Command

Business EnglishUniversity StudentsWorking Adults

FOR YOU

Vidéo recommandée

338 phrases

Vocabulaire et conseils d’expression pour cette leçon

Cette leçon d’expression orale de niveau C1 s’appuie sur la vidéo « Build a Microservice with Go - Getting Started ». Les mots qui reviennent le plus souvent : add, server, http, git, command. Cette vidéo contient 204 phrases et 3192 mots à répéter en shadowing. La partie parlée dure 16:16. Le locuteur parle vite, environ 196 mots par minute : attendez-vous à des liaisons et à des sons réduits. 83 % des mots font partie des 3 000 mots les plus courants en anglais ; le reste mérite d’être vu avant de commencer.

Vocabulaire clé de cette vidéo

Les 15 mots les plus avancés de la vidéo, avec leur prononciation et leur sens :

Mot	Prononciation	Sens
specify verbe	/ˈspɛs.əˌfaɪ/	spécifier
router nom	/ˈɹaʊ.tɚ/	routeur
initialize verbe	/ɪˈnɪʃəlaɪz/	initialiser
parameter nom	/pəˈɹæm.ə.tɚ/	paramètre
curl nom	/kɜɹl/	boucle
directory nom	/dɪˈɹɛktəɹi/	annuaire
binary adjectif	/ˈbaɪ.nə.ɹi/	binaire
conform verbe	/kənˈfɔɹm/	s'aligner
pointer nom	/ˈpɔɪn.təɹ/	aiguille
functionality nom		fonctionnalité
worthwhile adjectif	/ˌwɜː(ɹ)θˈwaɪl/	de valeur, qui en vaut la peine
decentralize verbe	/diːˈsɛntɹəlaɪz/	décentraliser
instantiate verbe	/ɪnˈstænʃieɪt/	instancier
repository nom	/ɹɪˈpɒz.ɪ.t(ə.)ɹɪ/	chambre-forte, coffre-fort
restart verbe	/ˈɹiːˌstɑɹt/	recommencer

Les verbes à particule que vous entendrez

Mot	Prononciation	Sens
go ahead verbe	/ˌɡoʊ əˈhɛd/	vas-y, allez-y
open up verbe		ouvrir
set up verbe	/ˌsɛt ˈʌp/	mettre en place, installer
check out verbe		mater, regarder
get back verbe		retourner
go through verbe		traverser
sign up verbe		inscrire

Des phrases à répéter

Des phrases courtes et complètes de la vidéo, à réutiliser dans la conversation de tous les jours :

Here I'm specifying my github repository.
Let's jump over to a new terminal window.
Let's go ahead and create one.
Let's try this by adding chi to our project.
There's one last thing for us to test.

La grammaire de cette vidéo

Les structures que le locuteur utilise le plus, avec les mots exacts de la vidéo :

Structure	Dans la vidéo
Voix passive be + participe passé — l’accent est mis sur ce qui arrive, pas sur qui le fait	is installed · is specified · are organised
Propositions relatives who / which + proposition — une précision sur une personne ou une chose	package, which is · servers, which is · ampersand, which means
Present perfect have/has + participe passé — une action passée qui compte encore maintenant	I've brought · haven't noticed · We've just created

Prononciation à surveiller

Le locuteur utilise 56 contractions et formes réduites, comme we're, we'll, I'm. Prononcez-les sous leur forme courte, telles que vous les entendez.

Les sons « th »: worthwhile /ˌwɜː(ɹ)θˈwaɪl/, underneath /ˌʌndɚˈniθ/
Les sons « sh » et « zh »: initialize /ɪˈnɪʃəlaɪz/, instantiate /ɪnˈstænʃieɪt/, abstraction /æbˈstɹæk.ʃn̩/, conventionally /kənˈvɛnʃənəli/
Mots longs — placez bien l’accent: initialize /ɪˈnɪʃəlaɪz/, parameter /pəˈɹæm.ə.tɚ/, directory /dɪˈɹɛktəɹi/, dependency /dɪˈpɛndənsi/, decentralize /diːˈsɛntɹəlaɪz/

Les sons difficiles pour les francophones :

/h/ — il se souffle, il n’est pas muet: handler /ˈhænd.lə/, hygiene /ˈhaɪˌd͡ʒiːn/, header /ˈhɛdɚ/
/tʃ/ et /dʒ/ — à ne pas adoucir en « ch » et « j »: hygiene /ˈhaɪˌd͡ʒiːn/, gem /d͡ʒɛm/, fortunately /ˈfɔɹ.t͡ʃə.nɪt.li/, junk /d͡ʒʌŋk/
/r/ anglais — langue recourbée, sans frotter la gorge: router /ˈɹaʊ.tɚ/, parameter /pəˈɹæm.ə.tɚ/, curl /kɜɹl/, directory /dɪˈɹɛktəɹi/, binary /ˈbaɪ.nə.ɹi/

Comment s’entraîner avec cette vidéo

Écoutez la vidéo en entier une fois sans parler et notez les mots que vous ne connaissez pas.
Commencez à la vitesse 0,75×, répétez phrase par phrase, puis revenez à la vitesse normale quand cela devient facile.
Enregistrez-vous et comparez avec l’original, en faisant attention à des mots comme specify, router, initialize.

Qu'est-ce que la technique du Shadowing ?

Le Shadowing est une technique d'apprentissage des langues fondée sur la science, développée à l'origine pour la formation des interprètes professionnels. Le principe est simple mais puissant : vous écoutez de l'anglais natif et le répétez immédiatement à voix haute — comme une ombre suivant le locuteur avec un décalage de 1 à 2 secondes. Les recherches montrent une amélioration significative de la précision de la prononciation, de l'intonation, du rythme, des liaisons, de la compréhension orale et de la fluidité.

Technique du shadowing : lire le guide complet étape par étape →

Pratique du Shadowing: Build a Microservice with Go #1 - Getting Started - Apprendre l'anglais à l'oral avec la vidéo

Choisissez un mode d'entraînement

Télécharger l'application

Spec Driven Workflow with Claude Code #1 - Making a /spec Command

I Wrapped an API Into a Real SaaS (full build / step-by-step)

What Are Microservices Really All About? (And When Not To Use It)

C++ in 100 Seconds

Kubernetes 101 - Episode 3 - Deploying Apps

Claude Code: The Advanced Guide (99% of Devs Skip These Features)

What is clean code? - Uncle Bob

Go’s Big Mistake

What's new in Google Cloud in less than 1 minute

Start building Shopify apps, FAST

How to Make Anything - Learn to Think Like an Engineer

mattpocock/skills: A complete AI Coding workflow, end-to-end

NGINX Explained - What is Nginx