
![Who will be successful?](/images/note-taking-is-new-electronic-game/1.jpeg)

His name is Jack Baty. He's tried just about every well-known blogging program, from WordPress, Ghost, hugo, [11ty](https://baty.blog/2023/eleventy-and-my-daily-notes/), [Blot](https://baty.blog/2022-09-01-2) to Write.as and more. What he says he appreciates about WordPress is that it works "out of the box": his default way of writing a blog is to click the Create Post button, type something in, and then click the Publish button. This way he doesn't have to worry about running scripts and dependencies. It's not as cool as clicking, typing, and clicking for dummies, but it's good for posting.

However, when trying Hugo, he said that he should have something cooler, that he should have to deal with more than just some HTML.

Unsurprisingly, he soon felt very uncomfortable with the WordPress editor again. After trying many editor programs, he felt he should use Static Site Generators.

He struggled with Hugo for a while. Now he left WordPress again, and went into the arms of static blogging to struggle with 11ty again. He gets tired of static blogs one minute and misses them the next; the same is true for WordPress.

He registered many domain names related to "baty" and tried to use different domain names for different blogs to record different types of content, notes, thoughts, long articles, pictures, etc. He uses [rl.baty.net](https://rl.baty.net/) to write his Wiki notes, which is built by TiddlyWiki note-taking software. He uses [rl.baty.net](https://rl.baty.net/) for his Wiki notes, which is built with TiddlyWiki note-taking software. He plans to use [baty.blog](https://baty.blog/) for his blog, and then says he's not sure if he'll change it to [blog.baty.net](https://blog.baty.net/). He uses [baty.net](https://baty.net/) for more formal and longer posts.

In [an post](https://write.as/jackbaty/domain-consolidation) on [Write.as](https://write.as/) he talks about his intention to merge domains. He says, "I've been feeling a need to simplify things and I've decided that one of those things is domain names. My days of hoarding domain names, just because, are drawing to a close. I don't want the hassle of managing zones and I don't need the fees."

He says he has a dream of One True Blog, which is probably why he's caught up in such an endless torturous process: wanting to have the one and only place to write on the web that fulfills all the important needs.

He tried using different editors for different types of blogs. From Emacs, [Typora](https://baty.blog/2019/typora-maybe), [Curio](https://baty.blog/2022/blogging-with-curio), Quine to [Ulysses](https://baty.blog/2022/ulysses-for-posting-to-wordpress) and more.

He's also tried blogging with a headless CMS, like Kirby.

In the course of tossing around blogging options, he voices somewhat desperate sentiments. For example, he lamented, "[I just want to post stuff](https://write.as/jackbaty/i-just-want-to-post-stuff)", "How should I do that? Ghost? WordPress? Write.as? Medium?"Also, he feels like he's "lost interest in everything" and "the only reason I still blogging every day is because I don't have anything better to do. I keep changing blogging platforms , but it's just a pastime with no real goal."

While noticing that he kept changing blogging platforms, I also noticed that he was constantly changing note-taking software. He tried almost all the well-known note-taking software such as Evernote, Roam Research, [TiddlyWiki](https://baty.blog/2020/tiddlywiki-is-more-fun-than-roam), [Tinderbox](https://www.eastgate.com/Tinderbox/), [Crafts](https://baty.blog/2021/craft-for-notes), Obsidian, Tana, and others. At first he was a Roam believer, then thought TiddlyWiki was more interesting than Roam, and then wonder, [what could be done with Crafts?](https://baty.blog/2021/craft-for-notes) He reflected, [Do backlinks really work?](https://baty.blog/2021/are-automatic-backlinks-useful)

In the course of tossing around note-taking software, he also emits somewhat despairing sentiments. For example, he says, "[**My new note-taking system: Don’t take notes**](https://baty.blog/2021/my-new-note-taking-system-dont-take-notes)," and he "feels like the entire world (or at least my corner of) is consumed by the 'how' of note-taking. Tools, workflows, processes, backlinks, and on and on. Obsidian? Roam? Paper? I read it all. It’s fun and interesting and there’s no end of things to distract myself with. A distraction is all it is." Then again, after trying Tana, he decided that [personal knowledge management had exhausted him](https://baty.blog/2022/personal-knowledge-management) and he was going to go back to paper in its most traditional form, the plain text editor.

That's it for this guy's story. By the way, I forgot to mention the fact that Baty has been unemployed for many years, and he has written "Hire me" in an obvious position on several websites.

I'm not introducing him to ridicule him, although he realizes he might be ridiculed. I can't remember exactly when I discovered Baty, but I was struck by his honesty of record.

I saw myself in him. Some time ago, when I was struggling to break away from the usual electronic games and realized that my blog had been inactive for months, I couldn't help but feel that I had just switched from one kind of electronic game to another.

Perhaps Baty is a mirror of everyone who is addicted to a new type of electronic game. The difference is that he has faithfully documented his record of tossing and turning, whereas many of us have either hidden the whole thing or left only a few words behind.

Here are a few facts I got from Baty's story, my own experiences and observations:

1. people who toss around new types of note-taking software have a good chance of also tossing around blogging programs;

2. people who are addicted to various efficiency tools are often losers who have little success in their industry or field;

3. people who are obsessed with new note-taking software or blogging programs spend more time playing ordinary electronic games and less time obsessing about the former, and vice versa;[^1]

4. new note-taking software and blogging programs are, in essence, new electronic games.

5. most busy and fulfilled people are unaware of new types of note-taking software or do not have a blog.

Of course, I don't present these facts as some kind of criticism (despite the Chinese old saying that "Excessive attention to plaything saps your will"). Most people, if they don't play this game, they play that game. It's just a bit of a paradox that the new electronic games are inherently associated with so-called efficiency, creativity, and productivity, when in fact they're just games.

[^1]: An example: "[With the recent game drought, it's just about time to weed the blog](https://www.giuem.com/blog/recent-updates-of-my-blog-2021#:~:text=%E5%92%8C%20bug%E3%80%82-,%E6%9C%80%E8%BF%91%E6%B8%B8%E6%88%8F%E8%8D%92%E4%BA%86%EF%BC%8C%E6%AD%A3%E5%A5%BD%E8%AF%A5%E7%BB%99%E5%8D%9A%E5%AE%A2%E9%99%A4%E9%99%A4%E8%8D%89%E4%BA%86,-%E3%80%82)."


In a sense, the new note-taking softwares and blogging programs are just new electronic games. In this article, I will introduce a friend who is addicted to a new type of electronic game. We can see ourselves from him.

New Note-taking Softwares are New Electronic Games


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 blogging