
In the previous blog, i wrote about how to deploy your backend to the cloud with dokku. deployment was manual where you had to push your code manually to your server so Dokku could build and run it.

In this blog i'll be using **Github Actions** to automate that.

## What is Continuous Deployment (CD)?

Continuous Deployment is a software engineering practice used to make the software development life cycle (SDLC) easier and more productive, by automating the deployment cycle using various techniques and tools.

## Github Actions

Github actions is an automation platform, provided by github to automate tasks like testing, building and deploying code directly from your github repo.

The github action workflow should be a **YAML** file defined inside **`your_project/.github/workflows`** folder, that's where github will look for your actions.

## Let's Automate it

The follwing is the content of my workflow used to automate the deployment of my app, Let's break it down.

```yaml
# .github/workflows/mycd.yaml
name: "Deploy my app backend"
on:
  push:
    branches:
      - master
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: 📌 Cloning repo
        uses: actions/checkout@v3
        with:
          fetch-depth: 0
          ref: refs/heads/master
          sparse-checkout: folder_that_contains_the_code
          sparse-checkout-cone-mode: false

      - name: 🚚 Push to dokku
        uses: dokku/github-action@master
        with:
          git_remote_url: "ssh://dokku@${{ secrets.MY_SERVER_IP }}:22/my_app_name"
          ssh_private_key: ${{ secrets.MY_SSH_KEY }}
```


- **`name:`** a user friendly name you give to your action to understand what workflow is running.

- **`on:`** github workflows are be triggered based on [events](https://docs.github.com/en/actions/about-github-actions/understanding-github-actions#events), such as a pull or push request. in this case we want to deploy the app on every `push` to the `master` branch.

- **`jobs:`** A [job](https://docs.github.com/en/actions/about-github-actions/understanding-github-actions#jobs) is the most important thing here, it's a set of steps, that can be either a shell script or an action that will be run. In this workflow we have 2 steps, the "Cloning repo" and "Push to dokku" steps. before that we have the `deploy` job, it's actually a customizable name you can name it whatever you want.

- **📌 Cloning repo:** to make your code accessible to the workflow, github provides an action template **actions/checkout@v3**. the template has a set of [configurations](https://github.com/actions/checkout?tab=readme-ov-file#usage). like the `ref` which defines the branch you want to access and `sparse-checkout` to checkout a specific folder/files.

- **🚚 Push to dokku:** the step that handles the deployment of the code. dokku provides the template [dokku/github-action@master](https://github.com/dokku/github-action) to deploy your code. It requires a set of configurations, including `git_remote_url` and `ssh_private_key`.
For security you need to hide your keys, you can define your secrets in the settings of your repo, go to **repo settings > Secrets and variables > Actions**, add your secrets, and they will be accessible inside the workflow under the **`secrets`** object.


How to Add Continuous Deployment to a Dokku App with GitHub Actions


Hi folks,

It’s been a long time since I wrote something. In this blog, I’ll be sharing **how to deploy your app backend to the cloud using Dokku**. The app will be a simple pastebin-like API built with NestJS and PostgreSQL.

## What is Dokku?
Dokku is like a tiny and free version of Heroku. You install it on your server, push your code, and Dokku handles the rest.

Your code is essentially pushed to a Git repository on your server that Dokku creates. When Dokku receives your push request, it creates a new container for the updated version. Once it succeeds, it shuts down the previous one, providing zero-downtime deployments.

Dokku has two deployment options: **buildpacks** and **dockerfiles**. In this blog, I’ll be using the first option, which is also the default in Dokku.

## What is a Buildpack?
A buildpack is a set of scripts that handle setting up, building, and running your application automatically. When you push your code, Dokku detects the language and applies the appropriate buildpack.

You can specify how the buildpack should run your application using a Procfile if you need a custom command. For example, if your app is built with Node.js, the buildpack will automatically detect this and try to run the app with `npm run start`.

You can override this behavior by creating a _Procfile_ at the root of your project.
Just like in our case, in nestjs to run the production build, npm start won't work, we need to run npm start:prod so my Procfile will contain this:
```bash
web: npm run start:prod
```

## Getting Started
Everything you need is in the Dokku documentation, but I’ll provide brief descriptions for each step and address some common pitfalls.

**1) Install Dokku**

SSH into your server and download the Dokku installation script:
```bash
wget -NP . https://dokku.com/bootstrap.sh
```

**2) Run the installer with:**
```bash
sudo DOKKU_TAG=v0.34.8 bash bootstrap.sh
```
The version might differ if you’re reading this in the future.

**3) Add your SSH key**

```bash
PUBLIC_KEY="your-public-key-contents-here"

echo "$PUBLIC_KEY" | dokku ssh-keys:add admin

# If you already copied your public key to your server before ssh you can just do
cat ~/.ssh/authorized_keys | dokku ssh-keys:add admin
```
When you push your code to the server, Dokku uses this SSH key for authentication.

Ok, so now we’ve finished setting up Dokku on our server.

## Domains
First, Dokku is not a DNS server; it just configures Nginx. Mapping your IP address to your custom domain should be handled by you. You can use Cloudflare, it’s secure, easy, and free.

To set a custom domain for your app, you have two options:

1. Set a global domain like _mydomain.com_. After creating a Dokku app, it will be accessible at _myapp.mydomain.com_.
```bash
dokku domains:set-global mydomain.com
```
The domain should be the root domain since your Dokku app’s name will be used as a subdomain (e.g., _mydokkuapp.mydomain.com_). This is the domain you need to point your IP address to.

2. If you don’t like having a global domain with subdomains for each app, you can set the domain separately for each app:
```bash
dokku domains:set myapp myapp.com
```
You’ll then need to point your IP address to _myapp.com_ to access it.

For this tutorial, I’ll set a global domain and make my apps accessible via subdomains.

## Creating Your App
Simply run:
```bash
dokku apps:create myapi
```
As mentioned, once your DNS records are configured, your app should be accessible at **myapi.mydomain.com**.

> [!TIP]
> You can see the port mappings for your app with `dokku ports:report myapp`.

> [!IMPORTANT]
> A common pitfall that might waste hours is the port mapping. By default, Dokku maps the HTTP port 80 to port 5000 inside your container. If your app runs on a different port like 3000 or 9999, you need to manually set the port with `dokku ports:set myapp http:80:MY_APP_PORT`.

## Database and Plugins
Now we need a database for storing pastebins. Dokku supports plugins for various services like PostgreSQL, MySQL, Mongo, ect... You can find all available plugins [here](https://dokku.com/docs/community/plugins/).

For this app, I’ll use PostgreSQL, so let’s install the plugin and link it to our app:
```bash
sudo dokku plugin:install https://github.com/dokku/dokku-postgres.git
```
This installs the PostgreSQL plugin. You can see available commands with `dokku postgres`.

Create a PostgreSQL service:
```bash
dokku postgres:create myapidb
```

Link the database to your app:
```bash
dokku postgres:link myapidb myapi
```
Dokku will set and return the `DATABASE_URL` environment variable.

> [!TIP]
> You can view all your Dokku app’s environment variables with `dokku config:show myappname`.

So far, we have:
- Created our app
- Installed PostgreSQL and linked it to the app

## Deploying the App
Deployment is as simple as pushing to a Git repository. First, add the remote:
```bash
git remote add prod dokku@MY_SERVER_IP:MY_DOKKU_APP_NAME
```
The remote username **must** be `dokku`, or the deployment will fail.

> [!NOTE]
> Dokku’s docs suggest that some tools or Git clients might require the upstream to be prefixed with `ssh://`, like this: `ssh://dokku@MY_SERVER_IP:MY_DOKKU_APP_NAME`.

If your SSH keys have a passphrase, pushing directly to the server will fail with a **permission denied** error. You need to register your private key with `ssh-agent`.

> [!NOTE]
> `ssh-agent` is a process that handles authentication for you. If your SSH keys are protected by a passphrase, you register them once with the agent, and it handles subsequent authentications.

```bash
# Start the SSH agent if it's not running:
eval "$(ssh-agent -s)"
# Register your private key:
ssh-add -k path/to/private.key
```

Now deploy your app:
```bash
git push prod master
```

When the deployment finishes, Dokku will display the domain where your app is accessible. Point your server IP to that domain, and everything should work as expected.

## Adding SSL
Adding SSL with Dokku is straightforward, and it even handles automatic renewal. Install the _Let’s Encrypt_ plugin:
```bash
sudo dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git
```

Set a global email address:
```bash
dokku letsencrypt:set --global email your-email@your.domain.com
```

Enable the plugin:
```bash
dokku letsencrypt:enable myapi
```

Enable auto-renewal:
```bash
dokku letsencrypt:cron-job --add
```

Enabling Let’s Encrypt will automatically map the HTTPS port (443) to your app. If your app runs on a different port than 5000, you’ll need to adjust the port mapping as mentioned [earlier](#domains).

> [!TIP]
> If you don't have a domain name and just want to play with dokku, visiting the ip directly might just show the default nginx page, this is because of the default nginx configuration, and dokku using the server hostname which won't resolve to anything. so just remove the default nginx config and everything should work fine `sudo rm -rf /etc/nginx/sites-enabled/default`

---


I hope you found this blog helpful, if you have any questions you can always reach out, i'll be so happy to help if i don't have so many tasks on my list 🙃

You can also check [dokku docs](https://dokku.com/docs) for more information.

I'm planning to write another blog on dokku, maybe, i hope so soon.


How to deploy your backend to the cloud with dokku


In this blog I will be using the **native Golang http package** to upload files, no third party packages. We will see how to upload single and multiple files.

## The HTML form

The form is simple and straight forward. The only thing to note is the `enctype="multipart/form-data"` attribute. This is required for uploading files.

```html
<form action="/upload" method="POST" enctype="multipart/form-data">
  <input name="name" type="text" placeholder="name" />
  <input name="ok" type="checkbox" placeholder="ok" value="aaaaa" /> aaaaa
  <input name="ok" type="checkbox" placeholder="ok" value="bbbbbb" /> bbbbbb
  <input type="file" name="file" id="file" />
  <button type="submit">SUBMIT!</button>
</form>
```

## Single file upload

```go
func uploadSingleFile(w http.ResponseWriter, r *http.Request){
  file, header, _ := r.FormFile("file") // FormFile automatically called ParseMultipartForm
  defer file.Close()

  // create a destination file
  dst, _ := os.Create(filepath.Join("./", header.Filename))
  defer dst.Close()

  // upload the file to destination path
  nb_bytes, _ := io.Copy(dst, file)

  fmt.Println("File uploaded successfully")
}
```

💡**Note:** All of the `_` underscore variables are errors, I just ignored them for the sake of simplicity. so don't do that in production.

As you noticed we get the uploaded file with the `r.FormFile("input_name_here")` function, it returns 3 variables, `file` which is the uploaded file itself, `header` which contains information about the file like the name, size, MIME type etc..., you can use these information to validate the file before uploading it, and finally `_` which is the error if any.

## Multiple files upload

First of all before you can select multiple files, you need to add the `multiple` attribute to the file input

```go
func uploadMultipleFiles(w http.ResponseWriter, r *http.Request){
  // key = "file" in the form
  //first of all ParseMultipartForm must be called 
  r.ParseMultipartForm(32 << 20)
  for key, files := range r.MultipartForm.File {
    for _, file := range files {
      dst, _ := os.Create(filepath.Join("./", file.Filename))
      f, _ := file.Open()
      io.Copy(dst, f)
    }
  }
}
```

Just FYI, the `r.MultipartForm.File` is a `map[string][]*multipart.FileHeader` where the key is the name of the input in the form. The `file` variable contains the same information as the `header` variable in the single file upload example, (size, name, MIME type etc...)

## The other fields

To get the other fields, there are two options, which at some point you will need to use both of them.

```go
// OPTION 1: returns a string which is the first value of the key
r.FormValue("name") // string

// OPTION 2: returns a slice of strings of all the values of the key
r.MultipartForm.Value["name"] // map[string][]string
```

You can use the first option when you want to get a single value, and the second option when you want to get multiple values, in our case the checkbox can have multiple values.

So `r.FormValue("name")` is like doing `r.MultipartForm.Value["name"][0]`.

---
That's it, I hope you enjoyed this tutorial, if you have any questions or suggestions, you can find all of this on GitHub.


How to upload files in Golang ?


*This article assumes that you have read about Golang, and know the basics at least.*

So let me start with the definition of concurrency,
it's simply the execution of some code instructions at the same time. that's it.

### Goroutines
*A goroutine is a lightweight thread of execution.*

> A Thread, or thread of execution, is a software term for the basic ordered sequence of instructions that can be passed through or processed by a single CPU core. - [stackoverflow](https://stackoverflow.com/questions/5201852/what-is-a-thread-really).

so goroutine lets us execute functions concurrently, how is that?
a simple example:
```go
package main

import (
	"fmt"
	"time"
)

func createUser(name string) {
  fmt.Println(name + " has been created successfully")
}
func uploadUserImage() {
  fmt.Println("User image has been successfully uploaded to the cloud !!")
}

func main() {
  go createUser("wassim")
  go uploadUserImage()

  time.Sleep(time.Second)
}

```
Output
```bash
User image has been successfully uploaded to the cloud !!
wassim has been created successfully
```

so as you can see the output of this simple program is not in the function order, cause they are executed concurrently so the result can be unordered.

*But wait a minute, why you put that time sleep at the end there ? is it necessary why is it necessary ?*

The Go program is going to finish executing when the main function ends, So, Our two function calls are running asynchronously in separate goroutines now. Waiting for them to finish, but the main function doesn't wait it doesn't know that the two functions are still running, so if we remove that sleep it won't print anything to the console. try it if you want.

now lets go to channels.

### Channels
*Channels are the pipes that connect concurrent goroutines. You can send values into channels from one goroutine and receive those values into another goroutine.*

lets start with code directly, here is an example using channels.

```go
package main

import (
	"fmt"
)

func createUser(name string, done chan<- bool) {
	fmt.Println(name + " has been created successfully")
	done <- true
}
func uploadUserImage(done chan<- bool) {
	fmt.Println("User image has been successfully uploaded to the cloud !!")
	done <- true
}

func main() {

	done := make(chan bool)

	go uploadUserImage(done)
	fmt.Println("Image uploaded: ", <-done)

	go createUser("wassim", done)
	fmt.Println("User created: ", <-done)
}
```

So let me first tell you what is the difference between this `chan<-` , this `<-chan` and this `chan`.

"chan" => in the function parameter, means that we will read and write from that channel, it's a data type.
"chan<-" => means that we will write only
"<-chan" => means that we will read-only

the output of this program:

```bash
User image has been successfully uploaded to the cloud !!
Image uploaded:  true
wassim has been created successfully
User created:  true
```


so in the main function we created a channel named done, we passed that channel as a parameter to our workers (createUser, and upload), and whenever a worker is done we notify the main function.
we put in the channel with `channelName <- VALUE`

and we consume the message from a channel like this `<-channelName`

if we don't consume the message, the goroutine function is not gonna print anything cause the main will not wait for it, so by using `<-done` we are telling the main function to wait until we get a message from the worker.
so if we removed this line here 
```go
fmt.Println("User created: ", <-done)
```
we will get an output like this:

```bash
User image has been successfully uploaded to the cloud !!
Image uploaded:  true
```

so `<-done` is simply blocking the main function from exiting. and therefore ending the program from executing.

And this is what is called *Channel Synchronization*, its just a fancy word that means blocking until a goroutine finish executing.

But, When waiting for multiple goroutines to finish, you may prefer to use a WaitGroup.


### WaitGroup
*To wait for multiple goroutines to finish, we can use a wait group.*

Again, lets jump directly to code, and then i will explain how and why.
```go
package main

import (
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func createUser(name string) {
	defer wg.Done()
	fmt.Println(name + " has been created successfully")
}

func uploadUserImage() {
	defer wg.Done()             // defer -> it will delay the execution of this func we upload the user image
	time.Sleep(time.Second * 3) // just to say that this is an expensive function (that took 3s)
	fmt.Println("User image has been successfully uploaded to the cloud !!")
}

func main() {

	go createUser("wassim")
	go uploadUserImage()

	wg.Add(2)
	wg.Wait()
}
```
well, to use WaitGroup, we need to import the sync package, then we declared a global variable wg.

now let me explain how the WaitGroup works. the `wg.Add(NUMBER_OF_GOROUTINES)` this function increment the number of the running goroutines, the `wg.Done()` will decrease the number of goroutines, so whenever a worker (function) is done working you fire the `wg.Done()` function the `defer` keyword just tells the function to delay until the main function ends its work **(by main function i mean its parent wich is the upload and create function)**, lastly the `wg.Wait()` this function blocks the program from exiting until the number of goroutines is 0. so `wg.Done()` will decrease until we reach the 0 then the `wg.Wait()` will fire, and the program exit/finish.

----
Thanks for reading, this is my first post, so if there is anything !good let me know :)

[More to learn about GO](https://gobyexample.com)


Understanding goroutines and concurrency in Golang


Heyy, it's me, this is my first blog post here. I will be sharing my thoughts, ideas, and experiences here. I hope you enjoy reading my posts as much as I enjoy writing them.

### Follow me

You can find me on [Twitter](https://twitter.com/bjwassim), [Github](https://github.com/wassimbj), and [LinkedIn](https://www.linkedin.com/in/wassimbenjdida). and you can find the code of this website [here](https://github.com/wassimbj/wassimbj.github.io).

```py
print 'Wish me luck 😁'
```
