![Encore logo](https://directus.tristandida.fr/assets/28f43c53-407d-4001-9336-53e906f38556)

<center>This article is based on the <a href="https://encore.dev/docs">official documentation</a>, this is the first part of a series of 2 posts</center>

## Quick start
### Create your project

First of all, you must have the Go compiler installed on your system, I recommend you to use the latest version (1.19.1 at the time or writing this article).

Then you can install the encore CLI, by using `brew` (the recommended version), or you can also curl the installation script directly

`curl -L https://encore.dev/install.sh | bash`

Once you're done, verify that you can run `encore` in your terminal!

You can now create the project, simply run `encore app create` and select the `Hello World` template.

<pre>~/DEV/GO/Blog ❯ encore app create
? App Name (lowercase letters, digits, and dashes) demo-blog
? Select app template: Hello World (Encore introduction)

Downloaded template hello-world.

Successfully created app demo-blog!
App ID: demo-blog-n8w2
Web URL: https://app.encore.dev/demo-blog-n8w2

Useful commands:

 encore run
 Run your app locally

 encore test ./...
 Run tests

 git push encore
 Deploys your app

Get started now: cd demo-blog &amp;&amp; encore run</pre>

### Sign in ?

You may have noticed that you have to sign in to the encore website in order to complete your project creation, this is a mandatory step that can not be skipped.
It is used for you to access the web dashboard, and facilitate the deployment if you want to use the cloud hosting.

![Encore web dashboard](https://directus.tristandida.fr/assets/76e19a6f-a4ac-45e8-b322-46d3c7454b1d)

### Start your app

Navigate to the newly created folder, then simply type `encore run` in your terminal.
<pre>
 ✔ Building Encore application graph... Done!
 ✔ Analyzing service topology... Done!
 ✔ Generating boilerplate code... Done!
 ✔ Compiling application source code... Done!
 ✔ Starting Encore application... Done!

 Encore development server running!

 Your API is running at: http://localhost:4000
 Development Dashboard URL: http://localhost:37193/testencore-fy8i

10:09AM INF registered API endpoint endpoint=World path=/hello/:name service=hello
10:09AM INF listening for incoming HTTP requests
</pre>

## The Hello World endpoint

The `Hello World` template come with an `Hello World` endpoint, you can make an HTTP request to `http://localhost:4000/hello/:name` to get a response saying hello to the name you used at the `:name` parameter.

<pre>~/DEV/GO/Blog ❯ curl -f http://localhost:4000/hello/Tristan
{
 &quot;Message&quot;: &quot;Hello, Tristan!&quot;
}
</pre>

Navigate to the `hello/hello.go` file, as you can see, it's mainly plain Go code, with a few things to notice.

If you look at the `World` function, you can notice a special comment just above :
```go
//encore:api public path=/hello/:name
func World(ctx context.Context, name string) (*Response, error) {
	msg := "Hello, " + name + "!"
	return &Response{Message: msg}, nil
}

type Response struct {
	Message string
}
```

The `//encore:api public path=/hello/:name` comment tells the Encore compiler that this function is exposed to the public API, with a certain path, which can contain a parameter.
This parameter can be automatically retrieved with function parameters.

The `Response` struct only represent the shape of the JSON response which will be returned to the user.

Note that you can make changes to the code, it will be auto-reloaded by Encore!

## The development dashboard

Encore come with a nice looking dashboard to help you debug, test, and inspect you app.
To access it, navigate to `http://localhost:4000`.

![Encore Dashboard](https://directus.tristandida.fr/assets/d2942215-6363-41c7-b3ce-80e454ac21cb)

The dashboard provide a tool for quickly testing your API endpoints (same as Swagger), some metrics regarding your last requests, an auto-generated API doc and a tool called `Flow`, that can be used to get an overview of all you app.

![Encore API Docs in the Dashboard](https://directus.tristandida.fr/assets/9703bc11-ed86-4e5a-a0a7-9618cca2c48e)

## Authentication

Let's add a simple authentication to our `/hello` route. To do so, you must replace the `public` access level by `auth` in the `//encore:api` comment.

```go
//encore:api auth path=/hello/:name
```

If you save the file now, you will get a Encore compilation error:
```
Changes detected, recompiling...
hello/hello.go:20:1: cannot use "auth" access type, no auth handler is defined in the app
```

That's right, we have to define a function that will handle our authentication:
```go
//encore:authhandler
func AuthHandler(ctx context.Context, token string) (auth.UID, error) {
	return "", &errs.Error{
		Code: errs.Unauthenticated,
		Message: "invalid token",
	}
}
```

We tell encore that this function is used as an `AuthHandler` with the `//encore:authhandler` comment. This function will receive a `Context` and a token.
The token come from the `Authorization: Bearer <token>` HTTP header.

Let's modify the function to integrate a very basic check:
```go
//encore:authhandler
func AuthHandler(ctx context.Context, token string) (auth.UID, error) {
	if token != "secret" {
		return "", &errs.Error{
			Code: errs.Unauthenticated,
			Message: "invalid token",
		}
	}

	return auth.UID("user"), nil
}
```

If the bearer token is `secret`, we authorize the user, simple as that!

Now, if you try to query the endpoint, you will get a `401 Unauthorized` error:
<pre>~/DEV/GO/Blog/demo-blog master ❯ curl http://localhost:4000/hello/Tristan
{
 &quot;code&quot;: &quot;unauthenticated&quot;,
 &quot;message&quot;: &quot;invalid auth param&quot;,
 &quot;details&quot;: null
}</pre>

But if you pass the `Authorization` header:
<pre>~/DEV/GO/Blog/demo-blog master ❯ curl -H &quot;Authorization: Bearer secret&quot; http://localhost:4000/hello/Tristan
{
 &quot;Message&quot;: &quot;Hello, Tristan!&quot;
}
</pre>

And voila, you can of course use an external auth provider like Firebase, Supabase, or your custom JWT logic.

Encore is a new backend web framework written in Go. It allows you to quickly create backend services with all kind of tools (databases, dependency injection, authentication, middlewares, etc..).
Let's take a quick look !

A quick introduction to Encore, a back-end framework for Go - Part 1

## Front-end

![NextJS logo](https://directus.tristandida.fr/assets/b079958a-2139-4456-b2eb-5f5c0bea0ded)

The front-end is rendered using mostly SSG (Server Side Generation), which means that every page is a static render. Only the `/revalidate` route is served with the NextJS backend.

This makes it possible to have a very good referencing because when the Google indexation bot browses the pages of this site, it sees HTML directly rendered by the server.

![Chakra UI logo](https://directus.tristandida.fr/assets/765e596c-d974-4793-86c8-665eda2d3e33)

[Chakra-UI](https://chakra-ui.com) is then used as the component library.

It offers dozens of fully customizable components, so you can spend less time building the style of the site, and focus on the content. The library is written in TypeScript which makes writing code very simple thanks to autocompletion.

## Back-end

The back-end stack is a bit more complicated than the front-end. That's not a problem, let's dive in!

### CMS

![Directus logo](https://directus.tristandida.fr/assets/1bee1c8b-1ba9-41ab-a3c6-2aba09109c37)

[Directus](https://directus.io/) is used here to fill all the content of this website, the homepage, all the sections, the blog...
It offer a nice looking backoffice to manage all the different entities, with a lot of predefined fields already available.

![Directus backoffice](https://directus.tristandida.fr/assets/9f4bf20d-0d54-467c-8458-4c9b6de0c0ec)

### Deployment

![GitHub logo](https://directus.tristandida.fr/assets/33fe033e-90a2-45ca-aeeb-3161806d4461)

The projet is versionned using Git and hosted on GitHub (currently in a private repo at the time of writing this article).

It uses GitHub actions to build a Docker image and push it to the GitHub Container Registry (GHCR).
When the image is pushed, the project is then deployed to a Kubernetes server using Helm, which we will discuss in the next section.

All the actions are triggered when a commit is push to the `main` branch.

### Server

![K8S Logo](https://directus.tristandida.fr/assets/3392cce8-5fe6-42e3-b119-2dd0e4548ba7)

The server on which this website is deployed is hosted at [PulseHeberg](https://pulseheberg.com/), it's a VPS with the following specs that are more than enough.

![PulseHeberg plan](https://directus.tristandida.fr/assets/a19e00fc-d0a3-4e5a-b0f5-06d0b1d678bd)

It hosts a Debian distro with K3S installed, to provide a clean Kubernetes installation.

Cert-Manager takes care of generating and refreshing the certificates using Let's Encrypt.

Finally, I have [Rancher](https://rancher.com) installed to provide a quick UI for interacting with the containers, beside that, all the deployments are made with [Helm](https://helm.sh).

![Rancher UI](https://directus.tristandida.fr/assets/3931b9e5-2e9f-40a2-bd88-9d134c23bb4b)

Creating your personal site is the perfect time to test new technologies and ways of doing things! In this article I suggest you discover in detail how the site you are on right now works.

A quick introduction to Encore, a back-end framework for Go - Part 1

The technical stack of this website