
In [Ghost on Fly.io for Free](/blog/ghost-on-fly-io-for-free/), we mentioned that the root environment of fly.io is temporary and will be restored when the app is redeployed or restarted, which was [confirmed](https://community.fly.io/t/will-restarting-the-app-reset-the-environment-configured-in-ssh-console/11167/2?u=pathsis) by the fly.io forum. This article shows how to wrap the Git environment into Docker to avoid the problem of Git environments being destroyed.

In fact, there are many ways to backup Ghost, besides the one we have described in the past using SFTP, there are [some](https://chlee.co/how-to-automatically-backup-a-self-hosted-ghost-blog-and-upload-to-aws-s3/) others , but these methods are really slow in transferring and backing up the full amount each time, compared to using Git, which is more elegant because it uses incremental backups and is extremely fast at copying! It's a little tedious to set up a Git environment, but it's a one-off.

## 1. Prepare the deployment files

We need to deploy a local Dockerfile instead of letting fly.io pull the official image automatically.

1.Go to Github and download the [official image](https://github.com/docker-library/ghost/tree/533294af2135d3b4e64e3620e66a4f4e314e0a44/5/debian). Download both of two files:

- docker-entrypoint.sh
- Dockerfile

  2.Open a terminal and run

```shell
mkdir blog
```

3.Copy the above two files to the `blog` folder, which is located under `/Users/<ComputerUserName>/blog`, your user folder.

4.Run

```shell
ssh-keygen -t rsa -C "<GithubEmail>"
```

Press enter continuously. Follow the prompts to see where the key is saved. Here is my example.

```shell
 ssh-keygen -t rsa -C "<GithubEmail>"
Generating public/private rsa key pair.
Enter file in which to save the key (/Users/<ComputerUserName>/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/<ComputerUserName>/.ssh/id_rsa
Your public key has been saved in /Users/<ComputerUserName>/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:siVmLMku/3BAem2ruRt44dEgdQsUBrKSAztU6HT1FIs k<GithubEmail>
The key's randomart image is:
+---[RSA 3072]----+
|o.++Bo.o.        |
|oB + o+..        |
|X o oE.o         |
|.+ = *           |
|  . O X S        |
|   = O *         |
|  o * +          |
|   + *           |
|    *+.          |
+----[SHA256]-----+
```

Go to the file `/Users/<ComputerUserName>/.ssh/` and copy the id_rsa and id_rsa.pub files to the blog folder.

Open id_rsa.pub with a text editor and add its contents to Github's SSH keys.

5.Continue to run

```shell
nano auto_backup.sh
```

Then, put the following code

```shell
#! /bin/sh

cd /var/lib/ghost/content # Switch to the directory
git config --global init.defaultBranch master
git config --global --add safe.directory /var/lib/ghost/content
git config --global pull.rebase false
git pull # Pull the repository
git add . # Add all
git commit -m "auto backup" # Commit
git push --force # Force a commit
```

Add to it. Press `CTRL`+`O` to save; press `CTRL`+`X` to exit the nano editor.

6.Open the Dockerfile and edit a few places. I recommend opening the blog folder with vs code.

Find `COPY docker-entrypoint.sh /usr/local/bin`, then, above it, paste the following code.

```shell
COPY id_rsa /root/.ssh/
COPY id_rsa.pub /root/.ssh/
COPY auto_backup.sh /usr/local/bin/auto_backup.sh
```

Find `ENV GHOST_VERSION`, then add the following code to the next line.

```shell
RUN apt-get update -y && apt-get upgrade -y && apt-get install -y  git nano
```

7.Refer to [previous post](https://pathos.page/blog/ghost-on-fly-io-for-free-en#2-install-ghost:~:text=This%20will%20create%20a%20fly.toml%20file%20in%20the%20blog%20directory.%20Open%20it%20with%20a%20text%20editor%20and%20overwrite%20it%20with%20the%20following%20code.) to prepare the fly.toml file. Note to remove

```toml
[build]
  image = "ghost:5"
```

8.This way, several local files that we use for deployment are ready, they are

- auto_backup.sh
- docker-entrypoint.sh
- Dockerfile
- fly.toml
- id_rsa
- id_rsa.pub

## 2. Deployment

Login:

```shell
flyctl auth login --email=<FlyMail> --password=<FlyPassword> --otp=<any letter>
```

Launch an app:

```shell
flyctl launch --image=Decokerfile --name=<AppName> -r hkg --no-deploy
```

Follow the prompts and press y to continue.

Create a volume:

```shell
flyctl volumes create data -r hkg --no-encryption --size 1
```

Deploy.

```shell
flyctl deploy
```

**NOTE**: If you have installed Ghost in the standard way, you should simply deploy.

## 3.Initialize Ghost

Refer to [previous post](https://pathos.page/blog/ghost-on-fly-io-for-free-en#3-initialize-ghost:~:text=show%20successful.-,3.%20Initialize%20Ghost,-Visit).

## 4. Backup

1.Verify the github connection

```shell
ssh git@github.com
```

Get the `successfully` prompt, that's it.

2.Initialize Git, run

```shell
cd /var/lib/ghost/content
git init
git config --global user.name "<GithubUsername>"
git config --global user.email <GithubMail>
git config --global --add safe.directory /var/lib/ghost/content
git remote add origin git@github.com:<GithubUsername>/<YourRepo>.git
git add .
git commit -m "auto backup"
git push -u origin master --force
```

Check for changes to the contents of the Github repository.

If there is an error, then run

```shell
cd /var/lib/ghost/
rm -rf content
```

It will prompt its BUSY, don't worry about it, it's already cleared.

After that, try to initialize Git again.

## 5.Restore

Assuming you have a fresh install of Ghost, you need to restore an existing backup in Github.

Unlike a backup, we need to pull rather than push the contents from Github.

```shell
rm -rf /var/lib/ghost/content
cd /var/lib/ghost/content
git init
git config --global user.name "<GithubUsername>"
git config --global user.email <GithubMail>
git config --global --add safe.directory /var/lib/ghost/content
git pull --force git@github.com:<GithubUsername>/<YourRepo>.git
```

If the repository is brand new, i.e. you copied your files directly into it but haven't connected to the remote repository yet, you may be prompted to run

```shell
git push --set-upstream origin master
```

Just execute the action.

## 6.Daily back up

First, give the automatic backup script execution privileges to, **in ssh console** run

```shell
chmod a+x /usr/local/bin/auto_backup.sh
```

Then, **in local machine**, run the following command

```shell
flyctl auth login --email=<FlyMail> --password=<FlyPassword> --otp=<any letter>
flyctl ssh console
sh /usr/local/bin/auto_backup.sh
```

You can write a script to automatically log into console and run it from **local machine** terminal

```shell
nano fly.sh
```

Paste the following code into it

```shell
cd blog
flyctl auth login --email=<FlyMail> --password=<FlyPassword> --otp=<any letter>
flyctl ssh console
```

Save and exit, then run

```shell
chmod a+x fly.sh
```

Put it into an aspect, like the desktop. To use it, drag it to the terminal, press enter, and it will go directly to the console.


This article shows how to package the Git environment into Docker to avoid the problem of Git environments being destroyed, to use Github backup Ghost.

Package Git into Ghost Docker Image


This article introduce how to install, backup and restore ghost on [fly.io](https://fly.io/) for free. Backing up and restoring data is a reference for use cases on other servers. With the use of cron, the full site data is regularly backed up to github, so to speak, you can really feel at ease with ghost and give up static blogs.

## 1. Pre-requisites

1. To register for a fly.io account,install flyctl command line, you need a credit card. (**required**)
2. be familiar with basic git commands. (not required)
3. Understand fly.io's [pricing](https://fly.io/docs/about/pricing/). (not required)
4. Understand Mailgun. (not required)

Install the command line

```shell
curl -L https://fly.io/install.sh | sh
```

For Windows，run

```shell
iwr https://fly.io/install.ps1 -useb | iex
```

## 2. Install Ghost

The following command is common on Linux and Mac.

Open a terminal and execute.

```shell
mkdir blog #Create a directory
cd blog #Enter this directory
flyctl auth login #Log in, then the browser will pop up the login session
flyctl launch --image=ghost:5 -r hkg --name=<AppName> --no-deploy
```

An explanation of the last command:

- The docker image used is `ghost:5`, indicating that the 5.x major version will be updated automatically on every deployment, and if you intend to check a specific version, such as 5.36.0, then replace 5 with it. [The official image is here](https://hub.docker.com/_/ghost).

- `- r hkg` means that the node of the selected server is Hong Kong (the node closest to us). [The region code of fly.io is here](https://fly.io/docs/reference/regions/#fly-io-regions).

- `--name=<AppName> ` means the name of the created app, replace `<AppName> ` with your own, and note that the default URL generated in the future is `<AppName>.fly.dev`, so please take a unique name.

- `--no-deploy` means don't deploy for now.

This will create a fly.toml file in the blog directory. Open it with a text editor and overwrite it with the following code.

```toml
app = "<AppName>"
kill_signal = "SIGINT"
kill_timeout = 5
processes = []

[build]
  image = "ghost:5"

[env]
  url = "https://<AppName>.fly.dev"
  database__client = "sqlite3"
  database__connection__filename = "content/data/ghost.db"
  database__debug = "false"
  database__useNullAsDefault = "true"
  mail__from = "noreply@example.com"
  mail__options__auth__pass = "<YourMailgunPassword>"
  mail__options__auth__user = "postmaster@example.com"
  mail__options__host = "smtp.mailgun.org"
  mail__options__port = "465"
  mail__transport = "SMTP"

[experimental]
  auto_rollback = true

[mounts]
  destination = "/var/lib/ghost/content"
  source = "data"

[[services]]
  http_checks = []
  internal_port = 2368
  processes = ["app"]
  protocol = "tcp"
  script_checks = []
  [services.concurrency]
    hard_limit = 25
    soft_limit = 20
    type = "connections"

  [[services.ports]]
    force_https = true
    handlers = ["http"]
    port = 80

  [[services.ports]]
    handlers = ["tls", "http"]
    port = 443

    [services.ports.http_options.response.headers]
      Referrer-Policy = "strict-origin"
      Strict-Transport-Security = "max-age=63072000; includeSubDomains; preload"
      X-Content-Type-Options = "nosniff"
      X-Frame-Options = "SAMEORIGIN"
      x-xss-protection = "1; mode=block"
      Permissions-Policy = "camera=(), microphone=(), geolocation=(), browsing-topics=()"

  [[services.tcp_checks]]
    grace_period = "1s"
    interval = "15s"
    restart_limit = 0
    timeout = "2s"
```

Please replace `<AppName>` with your own, and, if you don't use [Mailgun](https://ghost.org/docs/faq/mailgun-newsletters/), please remove all code starting with `mail__` below `[env]`.

The `[services.ports.http_options.response.headers]` section is **optional** and is used to set the http header. You can search item by item, `Strict-Transport-Security`, for example, to determine if you want to add them. After the deployment, you may go to the http header test [site](https://securityheaders.com/).

When you are done checking, save and close the fly.toml file. Then go back to the terminal and continue executing.

```shell
  flyctl volumes create data -r hkg --no-encryption --size 1 # Create a volume of size 1Gb with region hkg and no encryption (helps improve performance). The free amount is 3GB in total.
  flyctl deploy #deploy
```

Wait a few moments, the deployment is successful! It will show `successful`.

## 3. Initialize Ghost

Visit

```shell
https://<AppName>.fly.dev/ghost/
```

to initialize ghost. After this, you are free to use ghost to publish content. Binding domain names, backing up and restoring data are optional operations.

## 4. Bind the domain name

Run

```shell
  flyctl ips list
```

to see the IP address of your app. Then create A records for ipv4 and AAAA records for ipv6 on your DNS server, pointing to your domain name `example.com` (required). Create CNAME, `<AppName>.fly.dev`, pointing to your `www.example.com` (not required). Also known as

| type  | record | value               |
| ----- | ------ | ------------------- |
| A     | @      | ipv4 address        |
| AAAAA | @      | ipv6 address        |
| CNAME | www    | `<AppName>.fly.dev` |

**Note**: **Before** binding the domain name, make sure to create the DNS records correctly.

Then run

```shell
flyctl certs create example.com
flyctl certs create www.example.com
```

wait a moment and run

```shell
flyctl certs check example.com
flyctl certs check www.example.com
```

to check the certificate enactment, which usually takes about a minute or two as long as the DNS **advance** configuration is correct. Run

```shell
flyctl ips list
```

to check the certificate issuance status.

**Note**: Don't install certificates repeatedly because there is a limit, [only 5 certificates can be issued every 7 days](https://community.fly.io/t/awaiting-certification-11-hours/7635/8?u=pathsis). It is recommended to bind them after debugging the app.

## 5. Redeploy

Notice that in the fly.toml,

```toml
[env]
  url = "https://<AppName>.fly.dev"
```

is the address assigned by fly.io, and if you click on the home page title of the ghost site, it will redirect to this address, so when you bind your own domain, change it to

```toml
[env]
  url = "https://example.com"
```

Save and close, then run `flyctl deploy`.

## 6. Back up and restore

Every time in the future you need to go into your local configuration directory to use flyctl correctly.

### 6.1 Method 1: Use SFTP to bacup Ghost

The advantage is that no complicated configuration is needed, but the copy speed is slow.

#### 6.1.1 Back up

First login (assuming you need to back up later).

```shell
cd blog
flyctl auth login
```

Then run

```shell
flyctl ssh sftp shell -r -a <AppName>
```

When it succeeds, it will show `>>` (red), then run

```shell
get /var/lib/ghost/content/
```

This will backup the whole site data, including themes, images, videos, articles, etc. It's very slow, please be patient.

You can also backup only images and videos by running

```shell
get /var/lib/ghost/content/images/
get /var/lib/ghost/content/media/
```

This will generate a `content.zip`, or, `images.zip` and `media.zip` in the blog directory. back them up elsewhere, or name them `content-YYYY-MM-DD.zip`.

#### 6.1.2 Restore

Now suppose you reinstall a new ghost, assuming it is still on fly.io, then the installation directory will remain as `/var/lib/ghost/content/`. If you install ghost somewhere else in the future, like on AWS, make sure you create this directory instead of the usual tutorial `/var/www/ghost/content/`, otherwise you will have trouble recovering your data by **first** method.

Still run

```shell
cd blog
flyctl auth login
flyctl ssh sftp shell -r -a <AppName>
```

Then run

```shell
put content.zip /var/lib/ghost/content.zip
```

After success, create a new tab in the terminal and run

```shell
flyctl ssh console
```

again, in ssh, run

```shell
apt-get update && apt-get upgrade && apt-get install unzip
```

to install `unzip`. Then run

```shell
cd /var/lib/ghost/
unzip content.zip
```

It will overwrite the content folder directly.

To verify that the unzip was successful, run

```shell
cd /var/lib/ghost/content/images/
ls #List all the files in the current folder
```

to see if there is any new data.

To fix permissions, run

```shell
chown -R node:node /var/lib/ghost/content/
```

**Note**: Possible scenario, can't overwrite the content folder correctly, then try to backup only `/var/lib/ghost/content/images/` and `/var/lib/ghost/content/media/` instead. At this point run

```shell
put images.zip /var/lib/ghost/content/images.zip
put media.zip /var/lib/ghost/content/media.zip

rm -rf /var/lib/ghost/content/images/
rm -rf var/lib/ghost/content/media/

unzip /var/lib/ghost/content/images.zip
unzip /var/lib/ghost/content/media.zip
```

this may break the permissions of the content folder, so run

```shell
ls -l /var/lib/ghost/content/
```

to check the user and permissions of the images and media folders, if their permissions belong to root, then you can't upload images and videos anymore, then run

```shell
chown -R node:node /var/lib/ghost/content/
chown -R node:node /var/lib/ghost/content/images/
chown -R node:node /var/lib/ghost/content/media/
```

to fix it, note that `node` is the ghost user in the fly.io case, depending on the result of the `ls -l /var/lib/ghost/content/` command,, in any case make sure that the user of the images and media folders is the same as the user of the other files under `/content/`.

### 6.2 Method 2: Use Github to backup Ghost

The advantage is that it is fast to replicate data, but the disadvantage is that the installation and configuration is relatively complicated.

#### 6.2.1 Back up

1. Login and enter ssh

```shell
cd blog
flyctl auth login
flyctl ssh console
```

2. Install git

```shell
apt-get update && apt-get upgrade && apt-get install git
```

3. Create a private (recommended) repository on the github web side , assuming it is called `<YourRepository>`.

4. Generate the key

```shell
ssh-keygen -t rsa -C "<GithubEmail>" # Press the Enter key continuously
```

5. Terminal new tab, run

```shell
flyctl ssh sftp shell -r -a <AppName>
get /root/.ssh/id_rsa.pub
```

Go back to the blog folder and find the `id_rsa.pub` file, open it with a text editor, and copy the key from it. Add it to `setting→SSH and GPG keys→SSH keys` in github and save it.

Test the connection with github

```shell
ssh git@github.com
```

Pay attention to the word `successful`.

6. Initialize the content git

```shell
cd /var/lib/ghost/content/
git init
git config --global user.name "<GithubUsername>"
git config --global user.email <GithubEmail>
git config --global --add safe.directory /var/lib/ghost/content
git remote add origin git@github.com:<GithubUsername>/<YourRepository>.git
git add .
git commit -m "auto backup"
git push -u origin master --force
```

Make sure you successfully push to github.

7. Create a new script

```shell
apt-get update && apt-get upgrade && apt-get install nano
cd /var/lib/ghost/content/
nano auto_run.sh
```

Copy the following code into `auto_run.sh`

```shell
#! /bin/sh

cd /var/lib/ghost/content # Switch to the directory
git config --global init.defaultBranch master
git config --global --add safe.directory /var/lib/ghost/content
git pull # Pull the repository
git add . # Add a staging
git commit -m "auto backup" # Commit
git push --force
```

Press `ctrl`+`O` followed by `enter` to write; press `ctrl`+`x` to exit nano.

Give the file permission to run

```shell
chmod a+x auto_run.sh
```

Later, after logging into ssh, you can directly run

```shell
sh /var/lib/ghost/content/auto_run.sh
```

to execute a new push.

#### 6.2.2 Restore

1. Log in to shh, reinstall git and add the key without further ado.

2. Empty the content folder

```shell
cd /var/lib/ghost/
rm -rf content
```

It will return that the folder can't be deleted because its `busy`, it doesn't matter, it has been emptied, but not deleted.

3. Initialize the git in the content file and force a pull

```shell
cd /var/lib/ghost/content/
git init
git config --global user.name "<GithubUsername>"
git config --global user.email <GithubEmail>
git pull --force git@github.com:<GithubUsername>/<YourRepository>.git
```

4. Verify that the pull was successful

```shell
ls
```

5. Make sure the data is successfully pulled, then restart the app

```shell
fly apps restart <AppName>
```

As of now, restarting or redeploying will **clear** the installed environment and software, but will **not** delete the ghost data.

6. It is really difficult to run **cron** in docker, so don't try it. In a normal virtual machine, you can set up cron to run at regular intervals

```shell
sh /var/lib/ghost/content/auto_run.sh
```


This article introduce how to run a free ghost blog on fly.io to backup and restore data. Backing up and restoring data is informative for use cases on other servers.

Tagged with fly.io