Merge pull request #79 from jkaninda/develop

Update version
2025-12-06 13:39:41 +01:00 · 2024-09-10 23:11:28 +02:00 · 2024-09-10 23:10:24 +02:00 · 2024-09-10 23:04:12 +02:00 · 2024-09-10 23:01:26 +02:00 · 2024-09-09 07:17:51 +02:00
62 changed files with 4225 additions and 523 deletions
--- a/.DS_Store
+++ b/.DS_Store
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,14 +1,7 @@
 name: Build
 on:
  push:
-    branches: [ "main" ]
-  workflow_dispatch:
-      inputs:
-        docker_tag:
-          description: 'Docker tag'
-          required: true
-          default: 'latest' 
-          type: string
+    branches: ['develop']
 env:
  BUILDKIT_IMAGE: jkaninda/mysql-bkup
 jobs:
@@ -32,8 +25,8 @@ jobs:
        uses: docker/build-push-action@v3
        with:
          push: true
-          file: "./src/docker/Dockerfile"
-          platforms: linux/amd64,linux/arm64
+          file: "./docker/Dockerfile"
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
          tags: |
-           "${{env.BUILDKIT_IMAGE}}:latest"
-           "${{env.BUILDKIT_IMAGE}}:v0.2"
+            "${{env.BUILDKIT_IMAGE}}:develop-${{ github.sha }}"
+
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -0,0 +1,55 @@
+name: Deploy Documenation site to GitHub Pages
+
+on:
+  push:
+    branches: ['main']
+    paths:
+      - 'docs/**'
+      - '.github/workflows/deploy-docs.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: 'pages'
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2'
+          bundler-cache: true
+          cache-version: 0
+          working-directory: docs
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v2
+      - name: Build with Jekyll
+        working-directory: docs
+        run: bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
+        env:
+          JEKYLL_ENV: production
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v1
+        with:
+          path: 'docs/_site/'
+
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v1
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -0,0 +1,49 @@
+name: CI
+on:
+  push:
+    tags:
+      - v**
+env:
+  BUILDKIT_IMAGE: jkaninda/mysql-bkup
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      -
+        name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      -
+        name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      -
+        name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Log in to GHCR
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      -
+        name: Get the tag name
+        id: get_tag_name
+        run: echo "TAG_NAME=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+      -
+        name: Build and push
+        uses: docker/build-push-action@v3
+        with:
+          push: true
+          file: "./docker/Dockerfile"
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          tags: |
+            "${{env.BUILDKIT_IMAGE}}:${{ env.TAG_NAME }}"
+            "${{env.BUILDKIT_IMAGE}}:latest"
+            "ghcr.io/${{env.BUILDKIT_IMAGE}}:${{ env.TAG_NAME }}"
+            "ghcr.io/${{env.BUILDKIT_IMAGE}}:latest"
+
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,10 @@ backup
 data
 compose.yaml
 .env
+test.md
+.DS_Store
+mysql-bkup
+/.DS_Store
+/.idea
+bin
+Makefile
--- a/21
+++ b/21
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jonas Kaninda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/README.md
+++ b/README.md
@@ -1,255 +1,175 @@
 # MySQL Backup
-MySQL Backup tool, backup database to S3 or Object Storage
+MySQL Backup is a Docker container image that can be used to backup and restore MySQL database. It supports local storage, AWS S3 or any S3 Alternatives for Object Storage, and SSH compatible storage.
+It also supports __encrypting__ your backups using GPG.

-[![Build](https://github.com/jkaninda/mysql-bkup/actions/workflows/build.yml/badge.svg)](https://github.com/jkaninda/mysql-bkup/actions/workflows/build.yml)
+The [jkaninda/mysql-bkup](https://hub.docker.com/r/jkaninda/mysql-bkup) Docker image can be deployed on Docker, Docker Swarm and Kubernetes.
+It handles __recurring__ backups of postgres database on Docker and can be deployed as __CronJob on Kubernetes__ using local, AWS S3 or SSH compatible storage.
+
+It also supports database __encryption__ using GPG.
+
+[![Build](https://github.com/jkaninda/mysql-bkup/actions/workflows/release.yml/badge.svg)](https://github.com/jkaninda/mysql-bkup/actions/workflows/release.yml)
+[![Go Report](https://goreportcard.com/badge/github.com/jkaninda/mysql-bkup)](https://goreportcard.com/report/github.com/jkaninda/mysql-bkup)
 ![Docker Image Size (latest by date)](https://img.shields.io/docker/image-size/jkaninda/mysql-bkup?style=flat-square)
 ![Docker Pulls](https://img.shields.io/docker/pulls/jkaninda/mysql-bkup?style=flat-square)
+<a href="https://ko-fi.com/jkaninda"><img src="https://uploads-ssl.webflow.com/5c14e387dab576fe667689cf/5cbed8a4ae2b88347c06c923_BuyMeACoffee_blue.png" height="20" alt="buy ma a coffee"></a>

-> Run on:
+Successfully tested on:
 - Docker
+- Docker in Swarm mode
 - Kubernetes
+- OpenShift
+
+## Documentation is found at <https://jkaninda.github.io/mysql-bkup>
+
+
+## Links:

-> Links:
 - [Docker Hub](https://hub.docker.com/r/jkaninda/mysql-bkup)
 - [Github](https://github.com/jkaninda/mysql-bkup)

-> Postgres solution :
- [Postgress](https://github.com/jkaninda/pg-bkup)
-
+## PostgreSQL solution :

+- [PostgreSQL](https://github.com/jkaninda/pg-bkup)

 ## Storage:
- local
- s3
- Object storage
-## Usage
+- Local
+- AWS S3 or any S3 Alternatives for Object Storage
+- SSH remote server

-| Options       | Shorts | Usage                              |
-|---------------|--------|------------------------------------|
-| mysql_bkup    | bkup   | CLI utility                    |
-| --operation   | -o     | Set operation. backup or restore (default: backup)    |
-| --storage      | -s     | Set storage. local or s3 (default: local)        |
-| --file        | -f     | Set file name for restoration      |
-| --path        |      | Set s3 path without file name. eg: /custom_path      |
-| --dbname        | -d     | Set database name      |
-| --port        | -p     | Set database port (default: 3306)      |
-| --timeout     | -t     | Set timeout (default: 60s)        |
-| --help        | -h     | Print this help message and exit   |
-| --version     | -V     | Print version information and exit |
+## Quickstart

-## Backup database :
+### Simple backup using Docker CLI

-Simple backup usage
+To run a one time backup, bind your local volume to `/backup` in the container and run the `backup` command:

-```sh
-bkup --operation backup --dbname database_name
-```
-```sh
-bkup -o backup -d database_name
-```
-### S3
-
-```sh
-bkup --operation backup --storage s3 --dbname database_name
-```
-## Docker run:
-
-```sh
-docker run --rm --network your_network_name --name mysql-bkup -v $PWD/backup:/backup/ -e "DB_HOST=database_host_name" -e "DB_USERNAME=username" -e "DB_PASSWORD=password" jkaninda/mysql-bkup:latest  bkup -o backup -d database_name
+```shell
+ docker run --rm --network your_network_name \
+ -v $PWD/backup:/backup/ \
+ -e "DB_HOST=dbhost" \
+ -e "DB_USERNAME=username" \
+ -e "DB_PASSWORD=password" \
+ jkaninda/mysql-bkup backup -d database_name
 ```

-## Docker compose file:
+Alternatively, pass a `--env-file` in order to use a full config as described below.
+
+```yaml
+ docker run --rm --network your_network_name \
+ --env-file your-env-file \
+ -v $PWD/backup:/backup/ \
+ jkaninda/mysql-bkup backup -d database_name
+```
+
+### Simple backup in docker compose file
+
 ```yaml
-version: '3'
 services:
-  mariadb:
-    container_name: mariadb
-    image: mariadb
-    environment:
-      MYSQL_DATABASE: mariadb
-      MYSQL_USER: mariadb
-      MYSQL_PASSWORD: password
-      MYSQL_ROOT_PASSWORD: password
  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
    image: jkaninda/mysql-bkup
    container_name: mysql-bkup
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation backup -d database_name
+    command: backup
    volumes:
      - ./backup:/backup
-    environment:
-      - DB_PORT=3306
-      - DB_HOST=mariadb
-      - DB_USERNAME=mariadb
-      - DB_PASSWORD=password
-```
-## Restore database :
-
-Simple database restore operation usage
-
-```sh
-bkup --operation restore --dbname database_name --file database_20231217_115621.sql
-```
-
-```sh
-bkup -o restore -f database_20231217_115621.sql 
-```
-### S3
-
-```sh
-bkup --operation restore --storage s3 --file database_20231217_115621.sql 
-```
-
-## Docker run:
-
-```sh
-docker run --rm --network your_network_name --name mysql-bkup -v $PWD/backup:/backup/ -e "DB_HOST=database_host_name" -e "DB_USERNAME=username" -e "DB_PASSWORD=password" jkaninda/mysql-bkup  bkup -o backup -d database_name -f mydb_20231219_022941.sql.gz
-```
-
-## Docker compose file:
-
-```yaml
-version: '3'
-services:
-  mariadb:
-    container_name: mariadb
-    image: mariadb:latest
-    environment:
-      MYSQL_DATABASE: mariadb
-      MYSQL_USER: mariadb
-      MYSQL_PASSWORD: password
-      MYSQL_ROOT_PASSWORD: password
-  mysql-bkup:
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
-    command:
-      - /bin/sh
-      - -c
-      - bkup --operation restore --file database_20231217_115621.sql --dbname database_name
-    volumes:
-      - ./backup:/backup
-    environment:
-      #- FILE_NAME=mariadb_20231217_040238.sql # Optional if file name is set from command
-      - DB_PORT=3306
-      - DB_HOST=mariadb
-      - DB_NAME=mariadb
-      - DB_USERNAME=mariadb
-      - DB_PASSWORD=password
-```
-## Run 
-
-```sh
-docker-compose up -d
-```
-## Backup to S3
-
-```sh
-docker run --rm --privileged --device /dev/fuse --name mysql-bkup -e "DB_HOST=db_hostname" -e "DB_USERNAME=username" -e "DB_PASSWORD=password" -e "ACCESS_KEY=your_access_key" -e "SECRET_KEY=your_secret_key" -e "BUCKETNAME=your_bucket_name" -e "S3_ENDPOINT=https://eu2.contabostorage.com" jkaninda/mysql-bkup  bkup -o backup -s s3 -d database_name
-```
-> To change s3 backup path add this flag : --path myPath . default path is /mysql_bkup
-
-Simple S3 backup usage
-
-```sh
-bkup --operation backup --storage s3 --dbname mydatabase 
-```
-```yaml
-  mysql-bkup:
-    image: jkaninda/mysql-bkup
-    container_name: mysql-bkup
-    tty: true
-    privileged: true
-    devices:
-    - "/dev/fuse"
-    command:
-      - /bin/sh
-      - -c
-      - mysql_bkup --operation restore --storage s3 -f database_20231217_115621.sql.gz
    environment:
      - DB_PORT=3306
      - DB_HOST=mysql
-      - DB_NAME=mariadb
-      - DB_USERNAME=mariadb
+      - DB_NAME=foo
+      - DB_USERNAME=bar
      - DB_PASSWORD=password
-      - ACCESS_KEY=${ACCESS_KEY}
-      - SECRET_KEY=${SECRET_KEY}
-      - BUCKETNAME=${BUCKETNAME}
-      - S3_ENDPOINT=${S3_ENDPOINT}
-
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+       - web
+networks:
+  web:
 ```
-## Run "docker run" from crontab
+## Deploy on Kubernetes

-Make an automated backup (every night at 1).
+For Kubernetes, you don't need to run it in scheduled mode. You can deploy it as Job or CronJob.

-> backup_script.sh
-
-```sh
-#!/bin/sh
-DB_USERNAME='db_username'
-DB_PASSWORD='password'
-DB_HOST='db_hostname'
-DB_NAME='db_name'
-BACKUP_DIR='/some/path/backup/'
-
-docker run --rm --name mysql-bkup -v $BACKUP_DIR:/backup/ -e "DB_HOST=$DB_HOST" -e "DB_USERNAME=$DB_USERNAME" -e "DB_PASSWORD=$DB_PASSWORD" jkaninda/mysql-bkup:latest  bkup -o backup -d $DB_NAME
-```
-
-```sh
-chmod +x backup_script.sh
-```
-
-Your crontab looks like this:
-
-```conf
-0 1 * * * /path/to/backup_script.sh
-```
-
-## Kubernetes CronJob
-
-Simple Kubernetes CronJob usage:
+### Simple Kubernetes backup Job :

 ```yaml
 apiVersion: batch/v1
-kind: CronJob
+kind: Job
 metadata:
-  name: mysql-bkup-job
+  name: backup-job
 spec:
-  schedule: "0 1 * * *"
-  jobTemplate:
-    spec:
+  ttlSecondsAfterFinished: 100
  template:
    spec:
-          backoffLimit: 2
      containers:
-          - name: mysql-bkup
+        - name: pg-bkup
+          # In production, it is advised to lock your image tag to a proper
+          # release version instead of using `latest`.
+          # Check https://github.com/jkaninda/mysql-bkup/releases
+          # for a list of available releases.
          image: jkaninda/mysql-bkup
-            securityContext:
-              privileged: true
          command:
            - /bin/sh
            - -c
-            - bkup -o backup -s s3 --path /custom_path
+            - backup -d dbname
+          resources:
+            limits:
+              memory: "128Mi"
+              cpu: "500m"
          env:
-              - name: DB_PORT
-                value: "3306" 
            - name: DB_HOST
-                value: ""
-              - name: DB_NAME
-                value: ""
+              value: "mysql"
            - name: DB_USERNAME
-                value: ""
-              # Please use secret!
+              value: "user"
            - name: DB_PASSWORD
              value: "password"
-              - name: ACCESS_KEY
-                value: ""
-              - name: SECRET_KEY
-                value: ""
-              - name: BUCKETNAME
-                value: ""
-              - name: S3_ENDPOINT
-                value: "https://s3.amazonaws.com"
+          volumeMounts:
+            - mountPath: /backup
+              name: backup
+      volumes:
+        - name: backup
+          hostPath:
+            path: /home/toto/backup # directory location on host
+            type: Directory # this field is optional
      restartPolicy: Never
 ```
+## Available image registries
+
+This Docker image is published to both Docker Hub and the GitHub container registry.
+Depending on your preferences and needs, you can reference both `jkaninda/mysql-bkup` as well as `ghcr.io/jkaninda/mysql-bkup`:
+
+```
+docker pull jkaninda/mysql-bkup
+docker pull ghcr.io/jkaninda/mysql-bkup
+```
+
+Documentation references Docker Hub, but all examples will work using ghcr.io just as well.
+
+## Supported Engines
+
+This image is developed and tested against the Docker CE engine and Kubernetes exclusively.
+While it may work against different implementations, there are no guarantees about support for non-Docker engines.
+
+## References
+
+We decided to publish this image as a simpler and more lightweight alternative because of the following requirements:
+
+- The original image is based on `ubuntu` and requires additional tools, making it heavy.
+- This image is written in Go.
+- `arm64` and `arm/v7` architectures are supported.
+- Docker in Swarm mode is supported.
+- Kubernetes is supported.
+
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+## Authors
+
+**Jonas Kaninda**
+- <https://github.com/jkaninda>
+
+## Copyright
+
+Copyright (c) [2023] [Jonas Kaninda]
--- a/backup_script.sh
+++ b/backup_script.sh
@@ -1,8 +0,0 @@
-#!/bin/sh
-DB_USERNAME='db_username'
-DB_PASSWORD='password'
-DB_HOST='db_hostname'
-DB_NAME='db_name'
-BACKUP_DIR="$PWD/backup"
-
-docker run --rm --name mysql-bkup -v $BACKUP_DIR:/backup/ -e "DB_HOST=$DB_HOST" -e "DB_USERNAME=$DB_USERNAME" -e "DB_PASSWORD=$DB_PASSWORD" jkaninda/mysql-bkup:latest  bkup -o backup -db $DB_NAME
--- a/build.sh
+++ b/build.sh
@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-if [ $# -eq 0 ]
-  then
-    tag='latest'
-  else
-    tag=$1
-fi
-
-docker build -f src/docker/Dockerfile  -t jkaninda/mysql-bkup:$tag .
-
-docker-compose up -d
--- a/cmd/backup.go
+++ b/cmd/backup.go
@@ -0,0 +1,38 @@
+// Package cmd /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package cmd
+
+import (
+	"github.com/jkaninda/mysql-bkup/pkg"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+)
+
+var BackupCmd = &cobra.Command{
+	Use:     "backup ",
+	Short:   "Backup database operation",
+	Example: utils.BackupExample,
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) == 0 {
+			pkg.StartBackup(cmd)
+		} else {
+			utils.Fatal("Error, no argument required")
+		}
+	},
+}
+
+func init() {
+	//Backup
+	BackupCmd.PersistentFlags().StringP("storage", "s", "local", "Storage. local or s3")
+	BackupCmd.PersistentFlags().StringP("path", "P", "", "AWS S3 path without file name. eg: /custom_path or ssh remote path `/home/foo/backup`")
+	BackupCmd.PersistentFlags().StringP("mode", "m", "default", "Execution mode. default or scheduled")
+	BackupCmd.PersistentFlags().StringP("period", "", "0 1 * * *", "Schedule period time")
+	BackupCmd.PersistentFlags().BoolP("prune", "", false, "Delete old backup, default disabled")
+	BackupCmd.PersistentFlags().IntP("keep-last", "", 7, "Delete files created more than specified days ago, default 7 days")
+	BackupCmd.PersistentFlags().BoolP("disable-compression", "", false, "Disable backup compression")
+
+}
--- a/cmd/migrate.go
+++ b/cmd/migrate.go
@@ -0,0 +1,27 @@
+// Package cmd /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package cmd
+
+import (
+	"github.com/jkaninda/mysql-bkup/pkg"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+)
+
+var MigrateCmd = &cobra.Command{
+	Use:   "migrate",
+	Short: "Migrate database from a source database to a target database",
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) == 0 {
+			pkg.StartMigration(cmd)
+		} else {
+			utils.Fatal("Error, no argument required")
+
+		}
+
+	},
+}
--- a/cmd/restore.go
+++ b/cmd/restore.go
@@ -0,0 +1,30 @@
+package cmd
+
+import (
+	"github.com/jkaninda/mysql-bkup/pkg"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+)
+
+var RestoreCmd = &cobra.Command{
+	Use:     "restore",
+	Short:   "Restore database operation",
+	Example: utils.RestoreExample,
+	Run: func(cmd *cobra.Command, args []string) {
+		if len(args) == 0 {
+			pkg.StartRestore(cmd)
+		} else {
+			utils.Fatal("Error, no argument required")
+
+		}
+
+	},
+}
+
+func init() {
+	//Restore
+	RestoreCmd.PersistentFlags().StringP("file", "f", "", "File name of database")
+	RestoreCmd.PersistentFlags().StringP("storage", "s", "local", "Storage. local or s3")
+	RestoreCmd.PersistentFlags().StringP("path", "P", "", "AWS S3 path without file name. eg: /custom_path or ssh remote path `/home/foo/backup`")
+
+}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -0,0 +1,42 @@
+// Package cmd /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package cmd
+
+import (
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"os"
+)
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:     "mysql-bkup [Command]",
+	Short:   "MySQL Backup tool, backup database to S3 or Object Storage",
+	Long:    `MySQL Database backup and restoration tool. Backup database to AWS S3 storage or any S3 Alternatives for Object Storage.`,
+	Example: utils.MainExample,
+	Version: appVersion,
+}
+var operation = ""
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	err := rootCmd.Execute()
+	if err != nil {
+		os.Exit(1)
+	}
+}
+
+func init() {
+	rootCmd.PersistentFlags().StringP("dbname", "d", "", "Database name")
+	rootCmd.PersistentFlags().StringVarP(&operation, "operation", "o", "", "Set operation, for old version only")
+	rootCmd.AddCommand(VersionCmd)
+	rootCmd.AddCommand(BackupCmd)
+	rootCmd.AddCommand(RestoreCmd)
+	rootCmd.AddCommand(MigrateCmd)
+
+}
--- a/cmd/version.go
+++ b/cmd/version.go
@@ -0,0 +1,28 @@
+// Package cmd /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+)
+
+var appVersion = os.Getenv("VERSION")
+
+var VersionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show version",
+	Run: func(cmd *cobra.Command, args []string) {
+		Version()
+	},
+}
+
+func Version() {
+	fmt.Printf("Version: %s \n", appVersion)
+	fmt.Println()
+}
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -0,0 +1,83 @@
+FROM golang:1.22.5 AS build
+WORKDIR /app
+
+# Copy the source code.
+COPY . .
+# Installs Go dependencies
+RUN go mod download
+
+# Build
+RUN CGO_ENABLED=0 GOOS=linux go build -o /app/mysql-bkup
+
+FROM ubuntu:24.04
+ENV DB_HOST="localhost"
+ENV DB_NAME=""
+ENV DB_USERNAME=""
+ENV DB_PASSWORD=""
+ENV DB_PORT=3306
+ENV STORAGE=local
+ENV AWS_S3_ENDPOINT=""
+ENV AWS_S3_BUCKET_NAME=""
+ENV AWS_ACCESS_KEY=""
+ENV AWS_SECRET_KEY=""
+ENV AWS_REGION="us-west-2"
+ENV AWS_S3_PATH=""
+ENV AWS_DISABLE_SSL="false"
+ENV GPG_PASSPHRASE=""
+ENV SSH_USER=""
+ENV SSH_REMOTE_PATH=""
+ENV SSH_PASSWORD=""
+ENV SSH_HOST_NAME=""
+ENV SSH_IDENTIFY_FILE=""
+ENV SSH_PORT="22"
+ENV TARGET_DB_HOST=""
+ENV TARGET_DB_PORT=3306
+ENV TARGET_DB_NAME="localhost"
+ENV TARGET_DB_USERNAME=""
+ENV TARGET_DB_PASSWORD=""
+ARG DEBIAN_FRONTEND=noninteractive
+ENV VERSION="v1.2.5"
+ENV BACKUP_CRON_EXPRESSION=""
+ARG WORKDIR="/config"
+ARG BACKUPDIR="/backup"
+ARG BACKUP_TMP_DIR="/tmp/backup"
+ARG BACKUP_CRON="/etc/cron.d/backup_cron"
+ARG BACKUP_CRON_SCRIPT="/usr/local/bin/backup_cron.sh"
+LABEL author="Jonas Kaninda"
+
+RUN apt-get update -qq
+RUN apt install mysql-client supervisor cron gnupg -y
+
+# Clear cache
+RUN apt-get clean && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir $WORKDIR
+RUN mkdir $BACKUPDIR
+RUN mkdir -p $BACKUP_TMP_DIR
+RUN chmod 777 $WORKDIR
+RUN chmod 777 $BACKUPDIR
+RUN chmod 777 $BACKUP_TMP_DIR
+RUN touch $BACKUP_CRON && \
+    touch $BACKUP_CRON_SCRIPT && \
+    chmod 777 $BACKUP_CRON && \
+    chmod 777 $BACKUP_CRON_SCRIPT
+
+COPY --from=build /app/mysql-bkup /usr/local/bin/mysql-bkup
+RUN chmod +x /usr/local/bin/mysql-bkup
+
+RUN ln -s /usr/local/bin/mysql-bkup /usr/local/bin/bkup
+
+ADD docker/supervisord.conf /etc/supervisor/supervisord.conf
+
+# Create backup script and make it executable
+RUN echo '#!/bin/sh\n/usr/local/bin/mysql-bkup backup "$@"' > /usr/local/bin/backup && \
+    chmod +x /usr/local/bin/backup
+# Create restore script and make it executable
+RUN echo '#!/bin/sh\n/usr/local/bin/mysql-bkup restore "$@"' > /usr/local/bin/restore && \
+    chmod +x /usr/local/bin/restore
+# Create migrate script and make it executable
+RUN echo '#!/bin/sh\n/usr/local/bin/mysql-bkup migrate "$@"' > /usr/local/bin/migrate && \
+    chmod +x /usr/local/bin/migrate
+
+WORKDIR $WORKDIR
+ENTRYPOINT ["/usr/local/bin/mysql-bkup"]
--- a/docker/supervisord.conf
+++ b/docker/supervisord.conf
@@ -0,0 +1,13 @@
+[supervisord]
+nodaemon=true
+user=root
+logfile=/var/log/supervisor/supervisord.log
+pidfile=/var/run/supervisord.pid
+
+[program:cron]
+command = /bin/bash -c "declare -p | grep -Ev '^declare -[[:alpha:]]*r' > /run/supervisord.env && /usr/sbin/cron -f -L 15"
+autostart=true
+autorestart=true
+user = root
+stderr_logfile=/var/log/cron.err.log
+stdout_logfile=/var/log/cron.out.log
--- a/docs/.gitignore
+++ b/docs/.gitignore
@@ -0,0 +1,3 @@
+_site
+.sass-cache
+.jekyll-metadata
--- a/docs/404.html
+++ b/docs/404.html
@@ -0,0 +1,24 @@
+---
+layout: default
+---
+
+<style type="text/css" media="screen">
+  .container {
+    margin: 10px auto;
+    max-width: 600px;
+    text-align: center;
+  }
+  h1 {
+    margin: 30px 0;
+    font-size: 4em;
+    line-height: 1;
+    letter-spacing: -1px;
+  }
+</style>
+
+<div class="container">
+  <h1>404</h1>
+
+  <p><strong>Page not found :(</strong></p>
+  <p>The requested page could not be found.</p>
+</div>
--- a/docs/Dockerfile
+++ b/docs/Dockerfile
@@ -0,0 +1,12 @@
+FROM ruby:3.3.4
+
+ENV LC_ALL C.UTF-8
+ENV LANG en_US.UTF-8
+ENV LANGUAGE en_US.UTF-8
+
+WORKDIR /usr/src/app
+
+COPY . ./
+RUN gem install bundler && bundle install
+
+EXPOSE 4000
--- a/docs/Gemfile
+++ b/docs/Gemfile
@@ -0,0 +1,43 @@
+source "https://rubygems.org"
+
+# Hello! This is where you manage which Jekyll version is used to run.
+# When you want to use a different version, change it below, save the
+# file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
+#
+#     bundle exec jekyll serve
+#
+# This will help ensure the proper Jekyll version is running.
+# Happy Jekylling!
+gem "jekyll", "~> 3.10.0"
+
+# This is the default theme for new Jekyll sites. You may change this to anything you like.
+gem "minima", "~> 2.0"
+
+# If you want to use GitHub Pages, remove the "gem "jekyll"" above and
+# uncomment the line below. To umysqlrade, run `bundle update github-pages`.
+# gem "github-pages", group: :jekyll_plugins
+
+# If you have any plugins, put them here!
+group :jekyll_plugins do
+  gem "jekyll-feed", "~> 0.6"
+end
+
+# Windows and JRuby does not include zoneinfo files, so bundle the tzinfo-data gem
+# and associated library.
+platforms :mingw, :x64_mingw, :mswin, :jruby do
+  gem "tzinfo", ">= 1", "< 3"
+  gem "tzinfo-data"
+end
+
+# Performance-booster for watching directories on Windows
+gem "wdm", "~> 0.1.0", :install_if => Gem.win_platform?
+
+# kramdown v2 ships without the gfm parser by default. If you're using
+# kramdown v1, comment out this line.
+gem "kramdown-parser-gfm"
+
+# Lock `http_parser.rb` gem to `v0.6.x` on JRuby builds since newer versions of the gem
+# do not have a Java counterpart.
+gem "http_parser.rb", "~> 0.6.0", :platforms => [:jruby]
+gem "just-the-docs"
+
--- a/docs/Gemfile.lock
+++ b/docs/Gemfile.lock
@@ -0,0 +1,116 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
+    colorator (1.1.0)
+    concurrent-ruby (1.3.3)
+    csv (3.3.0)
+    em-websocket (0.5.3)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0)
+    eventmachine (1.2.7)
+    ffi (1.17.0)
+    ffi (1.17.0-aarch64-linux-gnu)
+    ffi (1.17.0-aarch64-linux-musl)
+    ffi (1.17.0-arm-linux-gnu)
+    ffi (1.17.0-arm-linux-musl)
+    ffi (1.17.0-arm64-darwin)
+    ffi (1.17.0-x86-linux-gnu)
+    ffi (1.17.0-x86-linux-musl)
+    ffi (1.17.0-x86_64-darwin)
+    ffi (1.17.0-x86_64-linux-gnu)
+    ffi (1.17.0-x86_64-linux-musl)
+    forwardable-extended (2.6.0)
+    http_parser.rb (0.8.0)
+    i18n (1.14.5)
+      concurrent-ruby (~> 1.0)
+    jekyll (3.10.0)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      csv (~> 3.0)
+      em-websocket (~> 0.5)
+      i18n (>= 0.7, < 2)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 2.0)
+      kramdown (>= 1.17, < 3)
+      liquid (~> 4.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (>= 1.7, < 4)
+      safe_yaml (~> 1.0)
+      webrick (>= 1.0)
+    jekyll-feed (0.17.0)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-include-cache (0.2.1)
+      jekyll (>= 3.7, < 5.0)
+    jekyll-sass-converter (1.5.2)
+      sass (~> 3.4)
+    jekyll-seo-tag (2.8.0)
+      jekyll (>= 3.8, < 5.0)
+    jekyll-watch (2.2.1)
+      listen (~> 3.0)
+    just-the-docs (0.8.2)
+      jekyll (>= 3.8.5)
+      jekyll-include-cache
+      jekyll-seo-tag (>= 2.0)
+      rake (>= 12.3.1)
+    kramdown (2.4.0)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    liquid (4.0.4)
+    listen (3.9.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    mercenary (0.3.6)
+    minima (2.5.1)
+      jekyll (>= 3.5, < 5.0)
+      jekyll-feed (~> 0.9)
+      jekyll-seo-tag (~> 2.1)
+    pathutil (0.16.2)
+      forwardable-extended (~> 2.6)
+    public_suffix (6.0.1)
+    rake (13.2.1)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.11.1)
+      ffi (~> 1.0)
+    rexml (3.3.2)
+      strscan
+    rouge (3.30.0)
+    safe_yaml (1.0.5)
+    sass (3.7.4)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    strscan (3.1.0)
+    wdm (0.1.1)
+    webrick (1.8.1)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  ruby
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  http_parser.rb (~> 0.6.0)
+  jekyll (~> 3.10.0)
+  jekyll-feed (~> 0.6)
+  just-the-docs
+  kramdown-parser-gfm
+  minima (~> 2.0)
+  tzinfo (>= 1, < 3)
+  tzinfo-data
+  wdm (~> 0.1.0)
+
+BUNDLED WITH
+   2.5.16
--- a/docs/_config.yml
+++ b/docs/_config.yml
@@ -0,0 +1,71 @@
+# Welcome to Jekyll!
+#
+# This config file is meant for settings that affect your whole blog, values
+# which you are expected to set up once and rarely edit after that. If you find
+# yourself editing this file very often, consider using Jekyll's data files
+# feature for the data you need to update frequently.
+#
+# For technical reasons, this file is *NOT* reloaded automatically when you use
+# 'bundle exec jekyll serve'. If you change this file, please restart the server process.
+
+# Site settings
+# These are used to personalize your new site. If you look in the HTML files,
+# you will see them accessed via {{ site.title }}, {{ site.email }}, and so on.
+# You can create any custom variable you would like, and they will be accessible
+# in the templates via {{ site.myvariable }}.
+title: MySQL Backup Docker container image
+email: hi@jonaskaninda.com
+description: >- # this means to ignore newlines until "baseurl:"
+  MySQL Backup is a Docker container image that can be used to backup and restore MySQL database. 
+  It supports local storage, AWS S3 or any S3 Alternatives for Object Storage, and SSH compatible storage.
+
+baseurl: "" # the subpath of your site, e.g. /blog
+url: "jkaninda.github.io/mysql-bkup/" # the base hostname & protocol for your site, e.g. http://example.com
+twitter_username: jonaskaninda
+github_username:  jkaninda
+
+callouts_level: quiet
+callouts:
+  highlight:
+    color: yellow
+  important:
+    title: Important
+    color: blue
+  new:
+    title: New
+    color: green
+  note:
+    title: Note
+    color: purple
+  warning:
+    title: Warning
+    color: red
+# Build settings
+markdown: kramdown
+theme: just-the-docs
+plugins:
+  - jekyll-feed
+aux_links:
+  'GitHub Repository':
+    - https://github.com/jkaninda/mysql-bkup
+
+nav_external_links:
+  - title: GitHub Repository
+    url: https://github.com/jkaninda/mysql-bkup
+
+footer_content: >-
+  Copyright &copy; 2024 <a target="_blank" href="https://www.jonaskaninda.com">Jonas Kaninda</a>.
+  Distributed under the <a href="https://github.com/jkaninda/mysql-bkup/tree/main/LICENSE">MIT License.</a><br>
+  Something missing, unclear or not working? Open <a href="https://github.com/jkaninda/mysql-bkup/issues">an issue</a>.
+
+# Exclude from processing.
+# The following items will not be processed, by default. Create a custom list
+# to override the default setting.
+# exclude:
+#   - Gemfile
+#   - Gemfile2.lock
+#   - node_modules
+#   - vendor/bundle/
+#   - vendor/cache/
+#   - vendor/gems/
+#   - vendor/ruby/
--- a/docs/_posts/2024-07-29-welcome-to-jekyll.markdown
+++ b/docs/_posts/2024-07-29-welcome-to-jekyll.markdown
@@ -0,0 +1,25 @@
+---
+layout: post
+title:  "Welcome to Jekyll!"
+date:   2024-07-29 03:36:13 +0200
+categories: jekyll update
+---
+You’ll find this post in your `_posts` directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run `jekyll serve`, which launches a web server and auto-regenerates your site when a file is updated.
+
+To add new posts, simply add a file in the `_posts` directory that follows the convention `YYYY-MM-DD-name-of-post.ext` and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.
+
+Jekyll also offers powerful support for code snippets:
+
+{% highlight ruby %}
+def print_hi(name)
+  puts "Hi, #{name}"
+end
+print_hi('Tom')
+#=> prints 'Hi, Tom' to STDOUT.
+{% endhighlight %}
+
+Check out the [Jekyll docs][jekyll-docs] for more info on how to get the most out of Jekyll. File all bugs/feature requests at [Jekyll’s GitHub repo][jekyll-gh]. If you have questions, you can ask them on [Jekyll Talk][jekyll-talk].
+
+[jekyll-docs]: https://jekyllrb.com/docs/home
+[jekyll-gh]:   https://github.com/jekyll/jekyll
+[jekyll-talk]: https://talk.jekyllrb.com/
--- a/docs/docker-compose.yml
+++ b/docs/docker-compose.yml
@@ -0,0 +1,13 @@
+services:
+  jekyll:
+    build:
+      context: ./
+    ports:
+      - 4000:4000
+    environment:
+      - JEKYLL_ENV=development
+    volumes:
+      - .:/usr/src/app
+    stdin_open: true
+    tty: true
+    command: bundle exec jekyll serve -H 0.0.0.0 -t
--- a/docs/how-tos/backup-to-s3.md
+++ b/docs/how-tos/backup-to-s3.md
@@ -0,0 +1,133 @@
+---
+title: Backup to AWS S3
+layout: default
+parent: How Tos
+nav_order: 2
+---
+# Backup to AWS S3 
+
+{: .note }
+As described on local backup section, to change the storage of you backup and use S3 as storage. You need to add `--storage s3` (-s s3).
+You can also specify a specify folder where you want to save you data by adding `--path /my-custom-path` flag.
+
+
+## Backup to S3
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup --storage s3 -d database --path /my-custom-path
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS configurations
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION="us-west-2"
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
+      - AWS_DISABLE_SSL="false"
+ 
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
+### Recurring backups to S3
+
+As explained above, you need just to add AWS environment variables and specify the storage type `--storage s3`.
+In case you need to use recurring backups, you can use `--mode scheduled` and specify the periodical backup time by adding `--period "0 1 * * *"` flag as described below.
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup --storage s3 -d my-database --mode scheduled --period "0 1 * * *"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+     ## AWS configurations
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION="us-west-2"
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
+      - AWS_DISABLE_SSL="false"
+     # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
+## Deploy on Kubernetes
+
+For Kubernetes, you don't need to run it in scheduled mode. You can deploy it as CronJob.
+
+### Simple Kubernetes CronJob usage:
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: bkup-job
+spec:
+  schedule: "0 1 * * *"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: mysql-bkup
+            image: jkaninda/mysql-bkup
+            command:
+            - /bin/sh
+            - -c
+            - backup -s s3 --path /custom_path
+            env:
+              - name: DB_PORT
+                value: "3306" 
+              - name: DB_HOST
+                value: ""
+              - name: DB_NAME
+                value: ""
+              - name: DB_USERNAME
+                value: ""
+              # Please use secret!
+              - name: DB_PASSWORD
+                value: ""
+              - name: AWS_S3_ENDPOINT
+                value: "https://s3.amazonaws.com"
+              - name: AWS_S3_BUCKET_NAME
+                value: "xxx"
+              - name: AWS_REGION
+                value: "us-west-2"    
+              - name: AWS_ACCESS_KEY
+                value: "xxxx"        
+              - name: AWS_SECRET_KEY
+                value: "xxxx"    
+              - name: AWS_DISABLE_SSL
+                value: "false"
+          restartPolicy: OnFailure
+```
--- a/docs/how-tos/backup-to-ssh.md
+++ b/docs/how-tos/backup-to-ssh.md
@@ -0,0 +1,140 @@
+---
+title: Backup to SSH
+layout: default
+parent: How Tos
+nav_order: 3
+---
+# Backup to SSH remote server
+
+
+As described for s3 backup section, to change the storage of your backup and use SSH Remote server as storage. You need to add `--storage ssh` or `--storage remote`.
+You need to add the full remote path by adding `--path /home/jkaninda/backups` flag or using `SSH_REMOTE_PATH` environment variable.
+
+{: .note }
+These environment variables are required for SSH backup `SSH_HOST_NAME`, `SSH_USER`, `SSH_REMOTE_PATH`, `SSH_IDENTIFY_FILE`, `SSH_PORT` or `SSH_PASSWORD` if you dont use a private key to access to your server.
+Accessing the remote server using password is not recommended, use private key instead.
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup --storage remote -d database
+    volumes:
+      - ./id_ed25519:/tmp/id_ed25519"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      #- DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## SSH config
+      - SSH_HOST_NAME="hostname"
+      - SSH_PORT=22
+      - SSH_USER=user
+      - SSH_REMOTE_PATH=/home/jkaninda/backups
+      - SSH_IDENTIFY_FILE=/tmp/id_ed25519
+      ## We advise you to use a private jey instead of password
+      #- SSH_PASSWORD=password
+
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
+
+### Recurring backups to SSH remote server
+
+As explained above, you need just to add required environment variables and specify the storage type `--storage ssh`.
+You can use `--mode scheduled` and specify the periodical backup time by adding `--period "0 1 * * *"` flag as described below.
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup -d database --storage ssh --mode scheduled --period "0 1 * * *"
+    volumes:
+      - ./id_ed25519:/tmp/id_ed25519"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## SSH config
+      - SSH_HOST_NAME="hostname"
+      - SSH_PORT=22
+      - SSH_USER=user
+      - SSH_REMOTE_PATH=/home/jkaninda/backups
+      - SSH_IDENTIFY_FILE=/tmp/id_ed25519
+      ## We advise you to use a private jey instead of password
+      #- SSH_PASSWORD=password
+     # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
+## Deploy on Kubernetes
+
+For Kubernetes, you don't need to run it in scheduled mode.
+You can deploy it as CronJob.
+
+Simple Kubernetes CronJob usage:
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: bkup-job
+spec:
+  schedule: "0 1 * * *"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: mysql-bkup
+            image: jkaninda/mysql-bkup
+            command:
+            - /bin/sh
+            - -c
+            - backup -s ssh
+            env:
+              - name: DB_PORT
+                value: "3306" 
+              - name: DB_HOST
+                value: ""
+              - name: DB_NAME
+                value: ""
+              - name: DB_USERNAME
+                value: ""
+              # Please use secret!
+              - name: DB_PASSWORD
+                value: ""
+              - name: SSH_HOST_NAME
+                value: ""
+              - name: SSH_PORT
+                value: "22"
+              - name: SSH_USER
+                value: "xxx"
+              - name: SSH_REMOTE_PATH
+                value: "/home/jkaninda/backups"    
+              - name: AWS_ACCESS_KEY
+                value: "xxxx"        
+              - name: SSH_IDENTIFY_FILE
+                value: "/tmp/id_ed25519"
+          restartPolicy: Never
+```
--- a/docs/how-tos/backup.md
+++ b/docs/how-tos/backup.md
@@ -0,0 +1,83 @@
+---
+title: Backup
+layout: default
+parent: How Tos
+nav_order: 1
+---
+
+# Backup database
+
+To backup the database, you need to add `backup` command.
+
+{: .note }
+The default storage is local storage mounted to __/backup__. The backup is compressed by default using gzip. The flag __`disable-compression`__ can be used when you need to disable backup compression.
+
+{: .warning }
+Creating a user for backup tasks who has read-only access is recommended!
+
+The backup process can be run in scheduled mode for the recurring backups.
+It handles __recurring__ backups of mysql database on Docker and can be deployed as __CronJob on Kubernetes__ using local, AWS S3 or SSH compatible storage.
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup -d database
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
+### Backup using Docker CLI
+
+```shell
+ docker run --rm --network your_network_name \
+ -v $PWD/backup:/backup/ \
+ -e "DB_HOST=dbhost" \
+ -e "DB_USERNAME=username" \
+ -e "DB_PASSWORD=password" \
+ jkaninda/mysql-bkup  backup -d database_name
+```
+
+In case you need to use recurring backups, you can use `--mode scheduled` and specify the periodical backup time by adding `--period "0 1 * * *"` flag as described below.
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup -d database --mode scheduled --period "0 1 * * *"
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
--- a/docs/how-tos/deploy-on-kubernetes.md
+++ b/docs/how-tos/deploy-on-kubernetes.md
@@ -0,0 +1,303 @@
+---
+title: Deploy on Kubernetes
+layout: default
+parent: How Tos
+nav_order: 8
+---
+
+## Deploy on Kubernetes
+
+To deploy MySQL Backup on Kubernetes, you can use Job to backup or Restore your database.
+For recurring backup you can use CronJob, you don't need to run it in scheduled mode. as described bellow.
+
+## Backup to S3 storage
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup
+spec:
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          # In production, it is advised to lock your image tag to a proper
+          # release version instead of using `latest`.
+          # Check https://github.com/jkaninda/mysql-bkup/releases
+          # for a list of available releases.
+          image: jkaninda/mysql-bkup
+          command:
+            - /bin/sh
+            - -c
+            - backup --storage s3
+          resources:
+            limits:
+              memory: "128Mi"
+              cpu: "500m"
+          env:
+            - name: DB_PORT
+              value: "3306"
+            - name: DB_HOST
+              value: ""
+            - name: DB_NAME
+              value: "dbname"
+            - name: DB_USERNAME
+              value: "username"
+            # Please use secret!
+            - name: DB_PASSWORD
+              value: ""
+            - name: AWS_S3_ENDPOINT
+              value: "https://s3.amazonaws.com"
+            - name: AWS_S3_BUCKET_NAME
+              value: "xxx"
+            - name: AWS_REGION
+              value: "us-west-2"
+            - name: AWS_ACCESS_KEY
+              value: "xxxx"
+            - name: AWS_SECRET_KEY
+              value: "xxxx"
+            - name: AWS_DISABLE_SSL
+              value: "false"
+      restartPolicy: Never
+```
+
+## Backup Job to SSH remote server
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    spec:
+      containers:
+      - name: mysql-bkup
+        # In production, it is advised to lock your image tag to a proper
+        # release version instead of using `latest`.
+        # Check https://github.com/jkaninda/mysql-bkup/releases
+        # for a list of available releases.
+        image: jkaninda/mysql-bkup
+        command:
+        - /bin/sh
+        - -c
+        - bkup
+        - backup
+        - --storage
+        - ssh
+        - --disable-compression
+        resources:
+          limits:
+            memory: "128Mi"
+            cpu: "500m"
+        env:
+          - name: DB_PORT
+            value: "3306"
+          - name: DB_HOST
+            value: ""
+          - name: DB_NAME
+            value: "dbname"
+          - name: DB_USERNAME
+            value: "username"
+          # Please use secret!
+          - name: DB_PASSWORD
+            value: ""
+          - name: SSH_HOST_NAME
+            value: "xxx"
+          - name: SSH_PORT
+            value: "22"
+          - name: SSH_USER
+            value: "xxx"
+          - name: SSH_PASSWORD
+            value: "xxxx"
+          - name: SSH_REMOTE_PATH
+            value: "/home/toto/backup"
+          # Optional, required if you want to encrypt your backup
+          - name: GPG_PASSPHRASE
+            value: "xxxx"
+      restartPolicy: Never
+```
+
+## Restore Job
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: restore-job
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    spec:
+      containers:
+      - name: mysql-bkup
+        # In production, it is advised to lock your image tag to a proper
+        # release version instead of using `latest`.
+        # Check https://github.com/jkaninda/mysql-bkup/releases
+        # for a list of available releases.
+        image: jkaninda/mysql-bkup
+        command:
+        - /bin/sh
+        - -c
+        - bkup
+        - restore
+        - --storage
+        - ssh
+        - --file store_20231219_022941.sql.gz
+        resources:
+          limits:
+            memory: "128Mi"
+            cpu: "500m"
+        env:
+        - name: DB_PORT
+          value: "3306" 
+        - name: DB_HOST
+          value: ""
+        - name: DB_NAME
+          value: "dbname"
+        - name: DB_USERNAME
+          value: "username"
+        # Please use secret!
+        - name: DB_PASSWORD
+          value: ""
+        - name: SSH_HOST_NAME
+          value: "xxx"
+        - name: SSH_PORT
+          value: "22"
+        - name: SSH_USER
+          value: "xxx"
+        - name: SSH_PASSWORD
+          value: "xxxx"
+        - name: SSH_REMOTE_PATH
+          value: "/home/xxxx/backup"
+          # Optional, required if your backup was encrypted
+        #- name: GPG_PASSPHRASE
+        #  value: "xxxx"
+      restartPolicy: Never
+```
+
+## Recurring backup
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: backup-job
+spec:
+  schedule: "* * * * *"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: mysql-bkup
+            image: jkaninda/mysql-bkup
+            command:
+            - /bin/sh
+            - -c
+            - bkup
+            - backup
+            - --storage
+            - ssh
+            - --disable-compression
+            resources:
+              limits:
+                memory: "128Mi"
+                cpu: "500m"
+            env:
+            - name: DB_PORT
+              value: "3306" 
+            - name: DB_HOST
+              value: ""
+            - name: DB_NAME
+              value: "username"
+            - name: DB_USERNAME
+              value: "username"
+            # Please use secret!
+            - name: DB_PASSWORD
+              value: ""
+            - name: SSH_HOST_NAME
+              value: "xxx"
+            - name: SSH_PORT
+              value: "xxx"
+            - name: SSH_USER
+              value: "jkaninda"
+            - name: SSH_REMOTE_PATH
+              value: "/home/jkaninda/backup"
+            - name: SSH_PASSWORD
+              value: "password"
+            # Optional, required if you want to encrypt your backup
+            #- name: GPG_PASSPHRASE
+            #  value: "xxx"
+          restartPolicy: Never
+```
+
+## Kubernetes Rootless
+
+This image also supports Kubernetes security context, you can run it in Rootless environment.
+It has been tested on Openshift, it works well.
+Deployment on OpenShift is supported, you need to remove `securityContext` section on your yaml file.
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: backup-job
+spec:
+  schedule: "* * * * *"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          securityContext:
+            runAsUser: 1000
+            runAsGroup: 3000
+            fsGroup: 2000
+          containers:
+            # In production, it is advised to lock your image tag to a proper
+            # release version instead of using `latest`.
+            # Check https://github.com/jkaninda/mysql-bkup/releases
+            # for a list of available releases.
+            - name: mysql-bkup
+              image: jkaninda/mysql-bkup
+              command:
+                - /bin/sh
+                - -c
+                - bkup
+                - backup
+                - --storage
+                - ssh
+                - --disable-compression
+              resources:
+                limits:
+                  memory: "128Mi"
+                  cpu: "500m"
+              env:
+                - name: DB_PORT
+                  value: "3306"
+                - name: DB_HOST
+                  value: ""
+                - name: DB_NAME
+                  value: "xxx"
+                - name: DB_USERNAME
+                  value: "xxx"
+                # Please use secret!
+                - name: DB_PASSWORD
+                  value: ""
+                - name: SSH_HOST_NAME
+                  value: "xxx"
+                - name: SSH_PORT
+                  value: "22"
+                - name: SSH_USER
+                  value: "jkaninda"
+                - name: SSH_REMOTE_PATH
+                  value: "/home/jkaninda/backup"
+                - name: SSH_PASSWORD
+                  value: "password"
+              # Optional, required if you want to encrypt your backup
+              #- name: GPG_PASSPHRASE
+              #  value: "xxx"
+          restartPolicy: OnFailure
+```
--- a/docs/how-tos/encrypt-backup.md
+++ b/docs/how-tos/encrypt-backup.md
@@ -0,0 +1,51 @@
+---
+title: Encrypt backups using GPG
+layout: default
+parent: How Tos
+nav_order: 7
+---
+# Encrypt backup
+
+The image supports encrypting backups using GPG out of the box. In case a `GPG_PASSPHRASE` environment variable is set, the backup archive will be encrypted using the given key and saved as a sql.gpg file instead or sql.gz.gpg.
+
+{: .warning }
+To restore an encrypted backup, you need to provide the same GPG passphrase used during backup process.
+
+To decrypt manually, you need to install `gnupg`
+
+### Decrypt backup
+
+```shell
+gpg --batch --passphrase "my-passphrase" \
+--output database_20240730_044201.sql.gz \
+--decrypt database_20240730_044201.sql.gz.gpg
+```
+
+### Backup
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup -d database
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## Required to encrypt backup
+      - GPG_PASSPHRASE=my-secure-passphrase
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
--- a/docs/how-tos/index.md
+++ b/docs/how-tos/index.md
@@ -0,0 +1,8 @@
+---
+title: How Tos
+layout: default
+nav_order: 3
+has_children: true
+---
+
+## How Tos
--- a/docs/how-tos/migrate.md
+++ b/docs/how-tos/migrate.md
@@ -0,0 +1,131 @@
+---
+title: Migrate database
+layout: default
+parent: How Tos
+nav_order: 9
+---
+
+# Migrate database
+
+To migrate the database, you need to add `migrate` command.
+
+{: .note }
+The Mysql backup has another great feature: migrating your database from a source database to a target.
+
+As you know, to restore a database from a source to a target database, you need 2 operations: which is to start by backing up the source database and then restoring the source backed database to the target database.
+Instead of proceeding like that, you can use the integrated feature `(migrate)`, which will help you migrate your database by doing only one operation.
+
+{: .warning }
+The `migrate` operation is irreversible, please backup your target database before this action.
+
+### Docker compose
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: migrate
+    volumes:
+      - ./backup:/backup
+    environment:
+      ## Source database
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## Target database
+      - TARGET_DB_HOST=target-mysql
+      - TARGET_DB_PORT=3306
+      - TARGET_DB_NAME=dbname
+      - TARGET_DB_USERNAME=username
+      - TARGET_DB_PASSWORD=password
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
+
+### Migrate database using Docker CLI
+
+
+```
+## Source database
+DB_HOST=mysql
+DB_PORT=3306
+DB_NAME=dbname
+DB_USERNAME=username
+DB_PASSWORD=password
+
+## Taget database
+TARGET_DB_HOST=target-mysql
+TARGET_DB_PORT=3306
+TARGET_DB_NAME=dbname
+TARGET_DB_USERNAME=username
+TARGET_DB_PASSWORD=password
+```
+
+```shell
+ docker run --rm --network your_network_name \
+ --env-file your-env
+ -v $PWD/backup:/backup/ \
+ jkaninda/mysql-bkup migrate
+```
+
+## Kubernetes
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: migrate-db
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    spec:
+      containers:
+      - name: mysql-bkup
+        # In production, it is advised to lock your image tag to a proper
+        # release version instead of using `latest`.
+        # Check https://github.com/jkaninda/mysql-bkup/releases
+        # for a list of available releases.
+        image: jkaninda/mysql-bkup
+        command:
+        - /bin/sh
+        - -c
+        - migrate
+        resources:
+          limits:
+            memory: "128Mi"
+            cpu: "500m"
+        env:
+        ## Source Database
+          - name: DB_HOST
+            value: "mysql"    
+          - name: DB_PORT
+            value: "3306"  
+          - name: DB_NAME
+            value: "dbname"
+          - name: DB_USERNAME
+            value: "username"
+          - name: DB_PASSWORD
+            value: "password"
+          ## Target Database
+          - name: TARGET_DB_HOST
+            value: "target-mysql"    
+          - name: TARGET_DB_PORT
+            value: "3306"
+          - name: TARGET_DB_NAME
+            value: "dbname"
+          - name: TARGET_DB_USERNAME
+            value: "username"
+          - name: TARGET_DB_PASSWORD
+            value: "password"
+      restartPolicy: Never
+```
--- a/docs/how-tos/restore-from-s3.md
+++ b/docs/how-tos/restore-from-s3.md
@@ -0,0 +1,95 @@
+---
+title: Restore database from AWS S3
+layout: default
+parent: How Tos
+nav_order: 5
+---
+
+# Restore database from S3 storage
+
+To restore the database, you need to add `restore` command and specify the file to restore by adding `--file store_20231219_022941.sql.gz`.
+
+{: .note }
+It supports __.sql__ and __.sql.gz__ compressed file.
+
+### Restore
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: restore --storage s3 -d my-database -f store_20231219_022941.sql.gz --path /my-custom-path
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS configurations
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION="us-west-2"
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
+      - AWS_DISABLE_SSL="false"
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+
+## Restore on Kubernetes
+
+Simple Kubernetes restore Job:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: restore-db
+spec:
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          image: jkaninda/mysql-bkup
+          command:
+            - /bin/sh
+            - -c
+            - restore -s s3 --path /custom_path -f store_20231219_022941.sql.gz
+          env:
+            - name: DB_PORT
+              value: "3306"
+            - name: DB_HOST
+              value: ""
+            - name: DB_NAME
+              value: ""
+            - name: DB_USERNAME
+              value: ""
+            # Please use secret!
+            - name: DB_PASSWORD
+              value: ""
+            - name: AWS_S3_ENDPOINT
+              value: "https://s3.amazonaws.com"
+            - name: AWS_S3_BUCKET_NAME
+              value: "xxx"
+            - name: AWS_REGION
+              value: "us-west-2"
+            - name: AWS_ACCESS_KEY
+              value: "xxxx"
+            - name: AWS_SECRET_KEY
+              value: "xxxx"
+            - name: AWS_DISABLE_SSL
+              value: "false"
+      restartPolicy: Never
+  backoffLimit: 4
+```
--- a/docs/how-tos/restore-from-ssh.md
+++ b/docs/how-tos/restore-from-ssh.md
@@ -0,0 +1,93 @@
+---
+title: Restore database from SSH
+layout: default
+parent: How Tos
+nav_order: 6
+---
+# Restore database from SSH remote server
+
+To restore the database from your remote server, you need to add `restore` command and specify the file to restore by adding `--file store_20231219_022941.sql.gz`.
+
+{: .note }
+It supports __.sql__ and __.sql.gz__ compressed file.
+
+### Restore
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: restore --storage ssh -d my-database -f store_20231219_022941.sql.gz --path /home/jkaninda/backups
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgres
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## SSH config
+      - SSH_HOST_NAME="hostname"
+      - SSH_PORT=22
+      - SSH_USER=user
+      - SSH_REMOTE_PATH=/home/jkaninda/backups
+      - SSH_IDENTIFY_FILE=/tmp/id_ed25519
+      ## We advise you to use a private jey instead of password
+      #- SSH_PASSWORD=password
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
+## Restore on Kubernetes
+
+Simple Kubernetes restore Job:
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: restore-db
+spec:
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          image: jkaninda/mysql-bkup
+          command:
+            - /bin/sh
+            - -c
+            - restore -s ssh -f store_20231219_022941.sql.gz
+          env:
+            - name: DB_PORT
+              value: "3306"
+            - name: DB_HOST
+              value: ""
+            - name: DB_NAME
+              value: ""
+            - name: DB_USERNAME
+              value: ""
+            # Please use secret!
+            - name: DB_PASSWORD
+              value: ""
+            - name: SSH_HOST_NAME
+              value: ""
+            - name: SSH_PORT
+              value: "22"
+            - name: SSH_USER
+              value: "xxx"
+            - name: SSH_REMOTE_PATH
+              value: "/home/jkaninda/backups"
+            - name: AWS_ACCESS_KEY
+              value: "xxxx"
+            - name: SSH_IDENTIFY_FILE
+              value: "/tmp/id_ed25519"
+      restartPolicy: Never
+  backoffLimit: 4
+```
--- a/docs/how-tos/restore.md
+++ b/docs/how-tos/restore.md
@@ -0,0 +1,40 @@
+---
+title: Restore database
+layout: default
+parent: How Tos
+nav_order: 4
+---
+
+# Restore database
+
+To restore the database, you need to add `restore` command and specify the file to restore by adding `--file store_20231219_022941.sql.gz`.
+
+{: .note }
+It supports __.sql__ and __.sql.gz__ compressed file.
+
+### Restore
+
+```yml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: restore -d database -f store_20231219_022941.sql.gz
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
+```
--- a/docs/index.md
+++ b/docs/index.md
@@ -0,0 +1,151 @@
+---
+title: Overview
+layout: home
+nav_order: 1
+---
+
+# About mysql-bkup
+{:.no_toc}
+MySQL Backup is a Docker container image that can be used to backup, restore and migrate MySQL database. It supports local storage, AWS S3 or any S3 Alternatives for Object Storage, and SSH remote storage.
+It also supports __encrypting__ your backups using GPG.
+
+We are open to receiving stars, PRs, and issues!
+
+
+{: .fs-6 .fw-300 }
+
+---
+
+The [jkaninda/mysql-bkup](https://hub.docker.com/r/jkaninda/mysql-bkup) Docker image can be deployed on Docker, Docker Swarm and Kubernetes. 
+It handles __recurring__ backups of postgres database on Docker and can be deployed as __CronJob on Kubernetes__ using local, AWS S3 or SSH compatible storage.
+
+It also supports database __encryption__ using GPG.
+
+
+{: .note }
+Code and documentation for `v1` version on [this branch][v1-branch].
+
+[v1-branch]: https://github.com/jkaninda/mysql-bkup
+
+---
+
+## Quickstart
+
+### Simple backup using Docker CLI
+
+To run a one time backup, bind your local volume to `/backup` in the container and run the `backup` command:
+
+```shell
+ docker run --rm --network your_network_name \
+ -v $PWD/backup:/backup/ \
+ -e "DB_HOST=dbhost" \
+ -e "DB_USERNAME=username" \
+ -e "DB_PASSWORD=password" \
+ jkaninda/mysql-bkup backup -d database_name
+```
+
+Alternatively, pass a `--env-file` in order to use a full config as described below.
+
+```yaml
+ docker run --rm --network your_network_name \
+ --env-file your-env-file \
+ -v $PWD/backup:/backup/ \
+ jkaninda/mysql-bkup backup -d database_name
+```
+
+### Simple backup in docker compose file
+
+```yaml
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=foo
+      - DB_USERNAME=bar
+      - DB_PASSWORD=password
+    # mysql-bkup container must be connected to the same network with your database
+    networks:
+       - web
+networks:
+  web:
+```
+## Kubernetes
+
+```yaml
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup-job
+spec:
+  ttlSecondsAfterFinished: 100
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          # In production, it is advised to lock your image tag to a proper
+          # release version instead of using `latest`.
+          # Check https://github.com/jkaninda/mysql-bkup/releases
+          # for a list of available releases.
+          image: jkaninda/mysql-bkup
+          command:
+            - /bin/sh
+            - -c
+            - backup -d dbname
+          resources:
+            limits:
+              memory: "128Mi"
+              cpu: "500m"
+          env:
+            - name: DB_HOST
+              value: "mysql"
+            - name: DB_USERNAME
+              value: "user"
+            - name: DB_PASSWORD
+              value: "password"
+          volumeMounts:
+            - mountPath: /backup
+              name: backup
+      volumes:
+        - name: backup
+          hostPath:
+            path: /home/toto/backup # directory location on host
+            type: Directory # this field is optional
+      restartPolicy: Never
+```
+
+## Available image registries
+
+This Docker image is published to both Docker Hub and the GitHub container registry.
+Depending on your preferences and needs, you can reference both `jkaninda/mysql-bkup` as well as `ghcr.io/jkaninda/mysql-bkup`:
+
+```
+docker pull jkaninda/mysql-bkup
+docker pull ghcr.io/jkaninda/mysql-bkup
+```
+
+Documentation references Docker Hub, but all examples will work using ghcr.io just as well.
+
+## Supported Engines
+
+This image is developed and tested against the Docker CE engine and Kubernetes exclusively.
+While it may work against different implementations, there are no guarantees about support for non-Docker engines.
+
+## References
+
+We decided to publish this image as a simpler and more lightweight alternative because of the following requirements:
+
+- The original image is based on `ubuntu` and requires additional tools, making it heavy.
+- This image is written in Go.
+- `arm64` and `arm/v7` architectures are supported.
+- Docker in Swarm mode is supported.
+- Kubernetes is supported.
--- a/docs/old-version/index.md
+++ b/docs/old-version/index.md
@@ -0,0 +1,358 @@
+---
+layout: page
+title: Old version
+permalink: /old-version/
+---
+
+This is the documentation of mysql-backup for all old versions bellow `v1.0`.
+In the old version, S3 storage was mounted using s3fs, so we decided to migrate to the official AWS SDK.
+
+## Storage:
+- local
+- s3
+- Object storage
+
+## Volumes:
+
+- /s3mnt => S3 mounting path
+- /backup => local storage mounting path
+
+### Usage
+
+| Options               | Shorts | Usage                                                                  |
+|-----------------------|--------|------------------------------------------------------------------------|
+| mysql-bkup            | bkup   | CLI utility                                                            |
+| backup                |        | Backup database operation                                              |
+| restore               |        | Restore database operation                                             |
+| history               |        | Show the history of backup                                             |
+| --storage             | -s     | Storage. local or s3 (default: local)                                  |
+| --file                | -f     | File name to restore                                                   |
+| --path                |        | S3 path without file name. eg: /custom_path                            |
+| --dbname              | -d     | Database name                                                          |
+| --port                | -p     | Database port (default: 3306)                                          |
+| --mode                | -m     | Execution mode. default or scheduled (default: default)                |
+| --disable-compression |        | Disable database backup compression                                    |
+| --prune               |        | Delete old backup, default disabled                                    |
+| --keep-last           |        | Delete old backup created more than specified days ago, default 7 days |
+| --period              |        | Crontab period for scheduled mode only. (default: "0 1 * * *")         |
+| --help                | -h     | Print this help message and exit                                       |
+| --version             | -V     | Print version information and exit                                     |
+
+
+## Environment variables
+
+| Name        | Requirement                                      | Description                                          |
+|-------------|--------------------------------------------------|------------------------------------------------------|
+| DB_PORT     | Optional, default 3306                           | Database port number                                 |
+| DB_HOST     | Required                                         | Database host                                        |
+| DB_NAME     | Optional if it was provided from the -d flag     | Database name                                        |
+| DB_USERNAME | Required                                         | Database user name                                   |
+| DB_PASSWORD | Required                                         | Database password                                    |
+| ACCESS_KEY  | Optional, required for S3 storage                | AWS S3 Access Key                                    |
+| SECRET_KEY  | Optional, required for S3 storage                | AWS S3 Secret Key                                    |
+| BUCKET_NAME | Optional, required for S3 storage                | AWS S3 Bucket Name                                   |
+| S3_ENDPOINT | Optional, required for S3 storage                | AWS S3 Endpoint                                      |
+| FILE_NAME   | Optional if it was provided from the --file flag | Database file to restore (extensions: .sql, .sql.gz) |
+
+
+## Note:
+
+Creating a user for backup tasks who has read-only access is recommended!
+
+> create read-only user
+
+
+## Backup database :
+
+Simple backup usage
+
+```sh
+bkup backup
+```
+
+### S3
+
+```sh
+mysql-bkup backup --storage s3
+```
+## Docker run:
+
+```sh
+docker run --rm --network your_network_name \
+--name mysql-bkup -v $PWD/backup:/backup/ \
+-e "DB_HOST=database_host_name" \
+-e "DB_USERNAME=username" \
+-e "DB_PASSWORD=password" jkaninda/mysql-bkup:v0.7  mysql-bkup backup -d database_name
+```
+
+## Docker compose file:
+```yaml
+version: '3'
+services:
+  postgres:
+    image: postgres:14.5
+    container_name: postgres
+    restart: unless-stopped
+    volumes:
+      - ./postgres:/var/lib/postgresql/data
+    environment:
+      POSTGRES_DB: bkup
+      POSTGRES_PASSWORD: password
+      POSTGRES_USER: bkup
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    depends_on:
+      - postgres
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup backup -d bkup
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgres
+      - DB_NAME=bkup
+      - DB_USERNAME=bkup
+      - DB_PASSWORD=password
+```
+## Restore database :
+
+Simple database restore operation usage
+
+```sh
+mysql-bkup restore --file database_20231217_115621.sql  --dbname database_name
+```
+
+```sh
+mysql-bkup restore -f database_20231217_115621.sql -d database_name
+```
+### S3
+
+```sh
+mysql-bkup restore --storage s3 --file database_20231217_115621.sql --dbname database_name
+```
+
+## Docker run:
+
+```sh
+docker run --rm --network your_network_name \
+--name mysql-bkup \
+-v $PWD/backup:/backup/ \
+-e "DB_HOST=database_host_name" \
+-e "DB_USERNAME=username" \
+-e "DB_PASSWORD=password" \
+jkaninda/mysql-bkup:v0.7   mysql-bkup restore -d database_name -f store_20231219_022941.sql.gz
+```
+
+## Docker compose file:
+
+```yaml
+version: '3'
+services:
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup restore --file database_20231217_115621.sql -d database_name
+    volumes:
+      - ./backup:/backup
+    environment:
+      #- FILE_NAME=database_20231217_040238.sql.gz # Optional if file name is set from command
+      - DB_PORT=3306
+      - DB_HOST=postgres
+      - DB_USERNAME=user_name
+      - DB_PASSWORD=password
+```
+## Run
+
+```sh
+docker-compose up -d
+```
+## Backup to S3
+
+```sh
+docker run --rm --privileged \
+--device /dev/fuse --name mysql-bkup \
+-e "DB_HOST=db_hostname" \
+-e "DB_USERNAME=username" \
+-e "DB_PASSWORD=password" \
+-e "ACCESS_KEY=your_access_key" \
+-e "SECRET_KEY=your_secret_key" \
+-e "BUCKETNAME=your_bucket_name" \
+-e "S3_ENDPOINT=https://s3.us-west-2.amazonaws.com" \
+jkaninda/mysql-bkup:v0.7  mysql-bkup backup -s s3 -d database_name
+```
+> To change s3 backup path add this flag : --path /my_customPath . default path is /mysql-bkup
+
+Simple S3 backup usage
+
+```sh
+mysql-bkup backup --storage s3 --dbname mydatabase 
+```
+```yaml
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    privileged: true
+    devices:
+    - "/dev/fuse"
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup restore --storage s3 -f database_20231217_115621.sql.gz --dbname database_name
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgress
+      - DB_USERNAME=user_name
+      - DB_PASSWORD=password
+      - ACCESS_KEY=${ACCESS_KEY}
+      - SECRET_KEY=${SECRET_KEY}
+      - BUCKET_NAME=${BUCKET_NAME}
+      - S3_ENDPOINT=${S3_ENDPOINT}
+
+```
+## Run in Scheduled mode
+
+This tool can be run as CronJob in Kubernetes for a regular backup which makes deployment on Kubernetes easy as Kubernetes has CronJob resources.
+For Docker, you need to run it in scheduled mode by adding `--mode scheduled` flag and specify the periodical backup time by adding `--period "0 1 * * *"` flag.
+
+Make an automated backup on Docker
+
+## Syntax of crontab (field description)
+
+The syntax is:
+
+- 1: Minute (0-59)
+- 2: Hours (0-23)
+- 3: Day (0-31)
+- 4: Month (0-12 [12 == December])
+- 5: Day of the week(0-7 [7 or 0 == sunday])
+
+Easy to remember format:
+
+```conf
+* * * * * command to be executed
+```
+
+```conf
+- - - - -
+| | | | |
+| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
+| | | ------- Month (1 - 12)
+| | --------- Day of month (1 - 31)
+| ----------- Hour (0 - 23)
+------------- Minute (0 - 59)
+```
+
+> At every 30th minute
+
+```conf
+*/30 * * * *
+```
+> “At minute 0.” every hour
+```conf
+0 * * * *
+```
+
+> “At 01:00.” every day
+
+```conf
+0 1 * * *
+```
+
+## Example of scheduled mode
+
+> Docker run :
+
+```sh
+docker run --rm --name mysql-bkup \
+-v $BACKUP_DIR:/backup/ \
+-e "DB_HOST=$DB_HOST" \
+-e "DB_USERNAME=$DB_USERNAME" \
+-e "DB_PASSWORD=$DB_PASSWORD" jkaninda/mysql-bkup:v0.7  mysql-bkup backup --dbname $DB_NAME --mode scheduled --period "0 1 * * *"
+```
+
+> With Docker compose
+
+```yaml
+version: "3"
+services:
+  mysql-bkup:
+    image: jkaninda/mysql-bkup:v0.7
+    container_name: mysql-bkup
+    privileged: true
+    devices:
+    - "/dev/fuse"
+    command:
+      - /bin/sh
+      - -c
+      - mysql-bkup backup --storage s3 --path /mys3_custom_path --dbname database_name --mode scheduled --period "*/30 * * * *"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=postgreshost
+      - DB_USERNAME=userName
+      - DB_PASSWORD=${DB_PASSWORD}
+      - ACCESS_KEY=${ACCESS_KEY}
+      - SECRET_KEY=${SECRET_KEY}
+      - BUCKET_NAME=${BUCKET_NAME}
+      - S3_ENDPOINT=${S3_ENDPOINT}
+```
+
+## Kubernetes CronJob
+
+For Kubernetes, you don't need to run it in scheduled mode.
+
+Simple Kubernetes CronJob usage:
+
+```yaml
+apiVersion: batch/v1
+kind: CronJob
+metadata:
+  name: bkup-job
+spec:
+  schedule: "0 1 * * *"
+  jobTemplate:
+    spec:
+      template:
+        spec:
+          containers:
+          - name: mysql-bkup
+            image: jkaninda/mysql-bkup:v0.7
+            securityContext:
+              privileged: true
+            command:
+            - /bin/sh
+            - -c
+            - mysql-bkup backup -s s3 --path /custom_path
+            env:
+              - name: DB_PORT
+                value: "3306" 
+              - name: DB_HOST
+                value: ""
+              - name: DB_NAME
+                value: ""
+              - name: DB_USERNAME
+                value: ""
+              # Please use secret!
+              - name: DB_PASSWORD
+                value: ""
+              - name: ACCESS_KEY
+                value: ""
+              - name: SECRET_KEY
+                value: ""
+              - name: BUCKET_NAME
+                value: ""
+              - name: S3_ENDPOINT
+                value: "https://s3.us-west-2.amazonaws.com"
+          restartPolicy: Never
+```
+
+## Authors
+
+**Jonas Kaninda**
+- <https://github.com/jkaninda>
+
--- a/docs/reference/index.md
+++ b/docs/reference/index.md
@@ -0,0 +1,113 @@
+---
+title: Configuration Reference
+layout: default
+nav_order: 2
+---
+
+# Configuration reference
+
+Backup, restore and migrate targets, schedule and retention are configured using environment variables or flags.
+
+
+
+
+
+###  CLI utility Usage
+
+| Options               | Shorts | Usage                                                                                  |
+|-----------------------|--------|----------------------------------------------------------------------------------------|
+| mysql-bkup            | bkup   | CLI utility                                                                            |
+| backup                |        | Backup database operation                                                              |
+| restore               |        | Restore database operation                                                             |
+| migrate               |        | Migrate database from one instance to another one                                      |
+| --storage             | -s     | Storage. local or s3 (default: local)                                                  |
+| --file                | -f     | File name for restoration                                                              |
+| --path                |        | AWS S3 path without file name. eg: /custom_path  or ssh remote path `/home/foo/backup` |
+| --dbname              | -d     | Database name                                                                          |
+| --port                | -p     | Database port (default: 3306)                                                          |
+| --mode                | -m     | Execution mode. default or scheduled (default: default)                                |
+| --disable-compression |        | Disable database backup compression                                                    |
+| --prune               |        | Delete old backup, default disabled                                                    |
+| --keep-last           |        | Delete old backup created more than specified days ago, default 7 days                 |
+| --period              |        | Crontab period for scheduled mode only. (default: "0 1 * * *")                         |
+| --help                | -h     | Print this help message and exit                                                       |
+| --version             | -V     | Print version information and exit                                                     |
+
+## Environment variables
+
+| Name                   | Requirement                                        | Description                                          |
+|------------------------|----------------------------------------------------|------------------------------------------------------|
+| DB_PORT                | Optional, default 3306                             | Database port number                                 |
+| DB_HOST                | Required                                           | Database host                                        |
+| DB_NAME                | Optional if it was provided from the -d flag       | Database name                                        |
+| DB_USERNAME            | Required                                           | Database user name                                   |
+| DB_PASSWORD            | Required                                           | Database password                                    |
+| AWS_ACCESS_KEY         | Optional, required for S3 storage                  | AWS S3 Access Key                                    |
+| AWS_SECRET_KEY         | Optional, required for S3 storage                  | AWS S3 Secret Key                                    |
+| AWS_BUCKET_NAME        | Optional, required for S3 storage                  | AWS S3 Bucket Name                                   |
+| AWS_BUCKET_NAME        | Optional, required for S3 storage                  | AWS S3 Bucket Name                                   |
+| AWS_REGION             | Optional, required for S3 storage                  | AWS Region                                           |
+| AWS_DISABLE_SSL        | Optional, required for S3 storage                  | Disable SSL                                          |
+| FILE_NAME              | Optional if it was provided from the --file flag   | Database file to restore (extensions: .sql, .sql.gz) |
+| BACKUP_CRON_EXPRESSION | Optional if it was provided from the --period flag | Backup cron expression for docker in scheduled mode  |
+| GPG_PASSPHRASE         | Optional, required to encrypt and restore backup   | GPG passphrase                                       |
+| SSH_HOST_NAME          | Optional, required for SSH storage                 | ssh remote hostname or ip                            |
+| SSH_USER               | Optional, required for SSH storage                 | ssh remote user                                      |
+| SSH_PASSWORD           | Optional, required for SSH storage                 | ssh remote user's password                           |
+| SSH_IDENTIFY_FILE      | Optional, required for SSH storage                 | ssh remote user's private key                        |
+| SSH_PORT               | Optional, required for SSH storage                 | ssh remote server port                               |
+| SSH_REMOTE_PATH        | Optional, required for SSH storage                 | ssh remote path (/home/toto/backup)                  |
+| TARGET_DB_HOST         | Optional, required for database migration          | Target database host                                 |
+| TARGET_DB_PORT         | Optional, required for database migration          | Target database port                                 |
+| TARGET_DB_NAME         | Optional, required for database migration          | Target database name                                 |
+| TARGET_DB_USERNAME     | Optional, required for database migration          | Target database username                             |
+| TARGET_DB_PASSWORD     | Optional, required for database migration          | Target database password                             |
+| TG_TOKEN               | Optional, required for Telegram notification       | Telegram token                                       |
+| TG_CHAT_ID             | Optional, required for Telegram notification       | Telegram Chat ID                                     |
+---
+## Run in Scheduled mode
+
+This image can be run as CronJob in Kubernetes for a regular backup which makes deployment on Kubernetes easy as Kubernetes has CronJob resources.
+For Docker, you need to run it in scheduled mode by adding `--mode scheduled` flag and specify the periodical backup time by adding `--period "0 1 * * *"` flag.
+
+## Syntax of crontab (field description)
+
+The syntax is:
+
+- 1: Minute (0-59)
+- 2: Hours (0-23)
+- 3: Day (0-31)
+- 4: Month (0-12 [12 == December])
+- 5: Day of the week(0-7 [7 or 0 == sunday])
+
+Easy to remember format:
+
+```conf
+* * * * * command to be executed
+```
+
+```conf
+- - - - -
+| | | | |
+| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
+| | | ------- Month (1 - 12)
+| | --------- Day of month (1 - 31)
+| ----------- Hour (0 - 23)
+------------- Minute (0 - 59)
+```
+
+> At every 30th minute
+
+```conf
+*/30 * * * *
+```
+> “At minute 0.” every hour
+```conf
+0 * * * *
+```
+
+> “At 01:00.” every day
+
+```conf
+0 1 * * *
+```
--- a/examples/docker-compose.s3.yaml
+++ b/examples/docker-compose.s3.yaml
@@ -0,0 +1,28 @@
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup --storage s3 -d my-database"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS configurations
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION="us-west-2"
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
+      - AWS_DISABLE_SSL="false"
+      # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
--- a/examples/docker-compose.scheduled.local.yaml
+++ b/examples/docker-compose.scheduled.local.yaml
@@ -0,0 +1,15 @@
+version: "3"
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup --dbname database_name --mode scheduled --period "0 1 * * *"
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_USERNAME=userName
+      - DB_PASSWORD=${DB_PASSWORD}
--- a/examples/docker-compose.scheduled.s3.yaml
+++ b/examples/docker-compose.scheduled.s3.yaml
@@ -0,0 +1,28 @@
+services:
+  mysql-bkup:
+    # In production, it is advised to lock your image tag to a proper
+    # release version instead of using `latest`.
+    # Check https://github.com/jkaninda/mysql-bkup/releases
+    # for a list of available releases.
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup --storage s3 -d my-database --mode scheduled --period "0 1 * * *"
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_NAME=database
+      - DB_USERNAME=username
+      - DB_PASSWORD=password
+      ## AWS configurations
+      - AWS_S3_ENDPOINT=https://s3.amazonaws.com
+      - AWS_S3_BUCKET_NAME=backup
+      - AWS_REGION="us-west-2"
+      - AWS_ACCESS_KEY=xxxx
+      - AWS_SECRET_KEY=xxxxx
+      ## In case you are using S3 alternative such as Minio and your Minio instance is not secured, you change it to true
+      - AWS_DISABLE_SSL="false"
+      # mysql-bkup container must be connected to the same network with your database
+    networks:
+      - web
+networks:
+  web:
--- a/examples/docker-compose.yaml
+++ b/examples/docker-compose.yaml
@@ -0,0 +1,13 @@
+version: "3"
+services:
+  mysql-bkup:
+    image: jkaninda/mysql-bkup
+    container_name: mysql-bkup
+    command: backup --dbname database_name
+    volumes:
+      - ./backup:/backup
+    environment:
+      - DB_PORT=3306
+      - DB_HOST=mysql
+      - DB_USERNAME=userName
+      - DB_PASSWORD=${DB_PASSWORD}
--- a/examples/k8s-job.yaml
+++ b/examples/k8s-job.yaml
@@ -0,0 +1,47 @@
+apiVersion: batch/v1
+kind: Job
+metadata:
+  name: backup
+spec:
+  template:
+    spec:
+      containers:
+        - name: mysql-bkup
+          # In production, it is advised to lock your image tag to a proper
+          # release version instead of using `latest`.
+          # Check https://github.com/jkaninda/mysql-bkup/releases
+          # for a list of available releases.
+          image: jkaninda/mysql-bkup
+          command:
+            - /bin/sh
+            - -c
+            - backup --storage s3
+          resources:
+            limits:
+              memory: "128Mi"
+              cpu: "500m"
+          env:
+            - name: DB_PORT
+              value: "3306"
+            - name: DB_HOST
+              value: ""
+            - name: DB_NAME
+              value: "dbname"
+            - name: DB_USERNAME
+              value: "username"
+            # Please use secret!
+            - name: DB_PASSWORD
+              value: ""
+            - name: AWS_S3_ENDPOINT
+              value: "https://s3.amazonaws.com"
+            - name: AWS_S3_BUCKET_NAME
+              value: "xxx"
+            - name: AWS_REGION
+              value: "us-west-2"
+            - name: AWS_ACCESS_KEY
+              value: "xxxx"
+            - name: AWS_SECRET_KEY
+              value: "xxxx"
+            - name: AWS_DISABLE_SSL
+              value: "false"
+      restartPolicy: Never
--- a/go.mod
+++ b/go.mod
@@ -0,0 +1,21 @@
+module github.com/jkaninda/mysql-bkup
+
+go 1.22.5
+
+require github.com/spf13/pflag v1.0.5
+
+require (
+	github.com/aws/aws-sdk-go v1.55.3
+	github.com/bramvdbogaerde/go-scp v1.5.0
+	github.com/hpcloud/tail v1.0.0
+	github.com/spf13/cobra v1.8.0
+	golang.org/x/crypto v0.18.0
+)
+
+require (
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/jmespath/go-jmespath v0.4.0 // indirect
+	golang.org/x/sys v0.22.0 // indirect
+	gopkg.in/fsnotify.v1 v1.4.7 // indirect
+	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
+)
--- a/go.sum
+++ b/go.sum
@@ -0,0 +1,38 @@
+github.com/aws/aws-sdk-go v1.55.3 h1:0B5hOX+mIx7I5XPOrjrHlKSDQV/+ypFZpIHOx5LOk3E=
+github.com/aws/aws-sdk-go v1.55.3/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
+github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+github.com/bramvdbogaerde/go-scp v1.5.0 h1:a9BinAjTfQh273eh7vd3qUgmBC+bx+3TRDtkZWmIpzM=
+github.com/bramvdbogaerde/go-scp v1.5.0/go.mod h1:on2aH5AxaFb2G0N5Vsdy6B0Ml7k9HuHSwfo1y0QzAbQ=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
+github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
+github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
+github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
+github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc=
+golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
+golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/k8s-job.yaml
+++ b/k8s-job.yaml
@@ -1,41 +0,0 @@
-apiVersion: batch/v1
-kind: CronJob
-metadata:
-  name: db-bkup-job
-spec:
-  schedule: "0 1 * * *"
-  jobTemplate:
-    spec:
-      template:
-        spec:
-          backoffLimit: 2
-          containers:
-          - name: mysql-bkup
-            image: jkaninda/mysql-bkup
-            securityContext:
-              privileged: true
-            command:
-            - /bin/sh
-            - -c
-            - bkup -o backup -s s3 --path /custom_path
-            env:
-              - name: DB_PORT
-                value: "3306" 
-              - name: DB_HOST
-                value: ""
-              - name: DB_NAME
-                value: ""
-              - name: DB_USERNAME
-                value: ""
-              # Please use secret!
-              - name: DB_PASSWORD
-                value: "password"
-              - name: ACCESS_KEY
-                value: ""
-              - name: SECRET_KEY
-                value: ""
-              - name: BUCKETNAME
-                value: ""
-              - name: S3_ENDPOINT
-                value: "https://s3.amazonaws.com"
-          restartPolicy: Never
--- a/main.go
+++ b/main.go
@@ -0,0 +1,15 @@
+// Package main /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package main
+
+import "github.com/jkaninda/mysql-bkup/cmd"
+
+func main() {
+
+	cmd.Execute()
+
+}
--- a/pkg/backup.go
+++ b/pkg/backup.go
@@ -0,0 +1,288 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"fmt"
+	"github.com/hpcloud/tail"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+)
+
+func StartBackup(cmd *cobra.Command) {
+	utils.Welcome()
+	//Set env
+	utils.SetEnv("STORAGE_PATH", storagePath)
+	utils.GetEnv(cmd, "period", "BACKUP_CRON_EXPRESSION")
+
+	//Get flag value and set env
+	remotePath := utils.GetEnv(cmd, "path", "SSH_REMOTE_PATH")
+	storage = utils.GetEnv(cmd, "storage", "STORAGE")
+	file = utils.GetEnv(cmd, "file", "FILE_NAME")
+	backupRetention, _ := cmd.Flags().GetInt("keep-last")
+	prune, _ := cmd.Flags().GetBool("prune")
+	disableCompression, _ = cmd.Flags().GetBool("disable-compression")
+	executionMode, _ = cmd.Flags().GetString("mode")
+	gpqPassphrase := os.Getenv("GPG_PASSPHRASE")
+	_ = utils.GetEnv(cmd, "path", "AWS_S3_PATH")
+
+	dbConf = getDbConfig(cmd)
+
+	//
+	if gpqPassphrase != "" {
+		encryption = true
+	}
+
+	//Generate file name
+	backupFileName := fmt.Sprintf("%s_%s.sql.gz", dbConf.dbName, time.Now().Format("20060102_150405"))
+	if disableCompression {
+		backupFileName = fmt.Sprintf("%s_%s.sql", dbConf.dbName, time.Now().Format("20060102_150405"))
+	}
+
+	if executionMode == "default" {
+		switch storage {
+		case "s3":
+			s3Backup(dbConf, backupFileName, disableCompression, prune, backupRetention, encryption)
+		case "local":
+			localBackup(dbConf, backupFileName, disableCompression, prune, backupRetention, encryption)
+		case "ssh", "remote":
+			sshBackup(dbConf, backupFileName, remotePath, disableCompression, prune, backupRetention, encryption)
+		case "ftp":
+			utils.Fatal("Not supported storage type: %s", storage)
+		default:
+			localBackup(dbConf, backupFileName, disableCompression, prune, backupRetention, encryption)
+		}
+
+	} else if executionMode == "scheduled" {
+		scheduledMode(dbConf, storage)
+	} else {
+		utils.Fatal("Error, unknown execution mode!")
+	}
+
+}
+
+// Run in scheduled mode
+func scheduledMode(db *dbConfig, storage string) {
+
+	fmt.Println()
+	fmt.Println("**********************************")
+	fmt.Println("     Starting MySQL Bkup...       ")
+	fmt.Println("***********************************")
+	utils.Info("Running in Scheduled mode")
+	utils.Info("Execution period  %s", os.Getenv("BACKUP_CRON_EXPRESSION"))
+	utils.Info("Storage type %s ", storage)
+
+	//Test database connexion
+	testDatabaseConnection(db)
+
+	utils.Info("Creating backup job...")
+	CreateCrontabScript(disableCompression, storage)
+
+	supervisorConfig := "/etc/supervisor/supervisord.conf"
+
+	// Start Supervisor
+	cmd := exec.Command("supervisord", "-c", supervisorConfig)
+	err := cmd.Start()
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Failed to start supervisord: %v", err))
+	}
+	utils.Info("Backup job started")
+	defer func() {
+		if err := cmd.Process.Kill(); err != nil {
+			utils.Info("Failed to kill supervisord process: %v", err)
+		} else {
+			utils.Info("Supervisor stopped.")
+		}
+	}()
+	if _, err := os.Stat(cronLogFile); os.IsNotExist(err) {
+		utils.Fatal(fmt.Sprintf("Log file %s does not exist.", cronLogFile))
+	}
+	t, err := tail.TailFile(cronLogFile, tail.Config{Follow: true})
+	if err != nil {
+		utils.Fatal("Failed to tail file: %v", err)
+	}
+
+	// Read and print new lines from the log file
+	for line := range t.Lines {
+		fmt.Println(line.Text)
+	}
+}
+
+// BackupDatabase backup database
+func BackupDatabase(db *dbConfig, backupFileName string, disableCompression bool) {
+	storagePath = os.Getenv("STORAGE_PATH")
+
+	err := utils.CheckEnvVars(dbHVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for database are set")
+		utils.Fatal("Error checking environment variables: %s", err)
+	}
+
+	utils.Info("Starting database backup...")
+	testDatabaseConnection(db)
+
+	// Backup Database database
+	utils.Info("Backing up database...")
+
+	if disableCompression {
+		// Execute mysqldump
+		cmd := exec.Command("mysqldump",
+			"-h", db.dbHost,
+			"-P", db.dbPort,
+			"-u", db.dbUserName,
+			"--password="+db.dbPassword,
+			db.dbName,
+		)
+		output, err := cmd.Output()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		// save output
+		file, err := os.Create(fmt.Sprintf("%s/%s", tmpPath, backupFileName))
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer file.Close()
+
+		_, err = file.Write(output)
+		if err != nil {
+			log.Fatal(err)
+		}
+		utils.Done("Database has been backed up")
+
+	} else {
+		// Execute mysqldump
+		cmd := exec.Command("mysqldump", "-h", db.dbHost, "-P", db.dbPort, "-u", db.dbUserName, "--password="+db.dbPassword, db.dbName)
+		stdout, err := cmd.StdoutPipe()
+		if err != nil {
+			log.Fatal(err)
+		}
+		gzipCmd := exec.Command("gzip")
+		gzipCmd.Stdin = stdout
+		gzipCmd.Stdout, err = os.Create(fmt.Sprintf("%s/%s", tmpPath, backupFileName))
+		gzipCmd.Start()
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := cmd.Run(); err != nil {
+			log.Fatal(err)
+		}
+		if err := gzipCmd.Wait(); err != nil {
+			log.Fatal(err)
+		}
+		utils.Done("Database has been backed up")
+
+	}
+
+}
+func localBackup(db *dbConfig, backupFileName string, disableCompression bool, prune bool, backupRetention int, encrypt bool) {
+	utils.Info("Backup database to local storage")
+	BackupDatabase(db, backupFileName, disableCompression)
+	finalFileName := backupFileName
+	if encrypt {
+		encryptBackup(backupFileName)
+		finalFileName = fmt.Sprintf("%s.%s", backupFileName, gpgExtension)
+	}
+	utils.Info("Backup name is %s", finalFileName)
+	moveToBackup(finalFileName, storagePath)
+	//Send notification
+	utils.NotifySuccess(finalFileName)
+	//Delete old backup
+	if prune {
+		deleteOldBackup(backupRetention)
+	}
+	//Delete temp
+	deleteTemp()
+}
+
+func s3Backup(db *dbConfig, backupFileName string, disableCompression bool, prune bool, backupRetention int, encrypt bool) {
+	bucket := utils.GetEnvVariable("AWS_S3_BUCKET_NAME", "BUCKET_NAME")
+	s3Path := utils.GetEnvVariable("AWS_S3_PATH", "S3_PATH")
+	utils.Info("Backup database to s3 storage")
+	//Backup database
+	BackupDatabase(db, backupFileName, disableCompression)
+	finalFileName := backupFileName
+	if encrypt {
+		encryptBackup(backupFileName)
+		finalFileName = fmt.Sprintf("%s.%s", backupFileName, "gpg")
+	}
+	utils.Info("Uploading backup archive to remote storage S3 ... ")
+	utils.Info("Backup name is %s", finalFileName)
+	err := utils.UploadFileToS3(tmpPath, finalFileName, bucket, s3Path)
+	if err != nil {
+		utils.Fatal("Error uploading file to S3: %s ", err)
+
+	}
+
+	//Delete backup file from tmp folder
+	err = utils.DeleteFile(filepath.Join(tmpPath, backupFileName))
+	if err != nil {
+		fmt.Println("Error deleting file: ", err)
+
+	}
+	// Delete old backup
+	if prune {
+		err := utils.DeleteOldBackup(bucket, s3Path, backupRetention)
+		if err != nil {
+			utils.Fatal("Error deleting old backup from S3: %s ", err)
+		}
+	}
+	utils.Done("Uploading backup archive to remote storage S3 ... done ")
+	//Send notification
+	utils.NotifySuccess(finalFileName)
+	//Delete temp
+	deleteTemp()
+}
+func sshBackup(db *dbConfig, backupFileName, remotePath string, disableCompression bool, prune bool, backupRetention int, encrypt bool) {
+	utils.Info("Backup database to Remote server")
+	//Backup database
+	BackupDatabase(db, backupFileName, disableCompression)
+	finalFileName := backupFileName
+	if encrypt {
+		encryptBackup(backupFileName)
+		finalFileName = fmt.Sprintf("%s.%s", backupFileName, "gpg")
+	}
+	utils.Info("Uploading backup archive to remote storage ... ")
+	utils.Info("Backup name is %s", finalFileName)
+	err := CopyToRemote(finalFileName, remotePath)
+	if err != nil {
+		utils.Fatal("Error uploading file to the remote server: %s ", err)
+
+	}
+
+	//Delete backup file from tmp folder
+	err = utils.DeleteFile(filepath.Join(tmpPath, finalFileName))
+	if err != nil {
+		fmt.Println("Error deleting file: ", err)
+
+	}
+	if prune {
+		//TODO: Delete old backup from remote server
+		utils.Info("Deleting old backup from a remote server is not implemented yet")
+
+	}
+
+	utils.Done("Uploading backup archive to remote storage ... done ")
+	//Send notification
+	utils.NotifySuccess(finalFileName)
+	//Delete temp
+	deleteTemp()
+}
+func encryptBackup(backupFileName string) {
+	gpgPassphrase := os.Getenv("GPG_PASSPHRASE")
+	err := Encrypt(filepath.Join(tmpPath, backupFileName), gpgPassphrase)
+	if err != nil {
+		utils.Fatal("Error during encrypting backup %s", err)
+	}
+
+}
--- a/pkg/config.go
+++ b/pkg/config.go
@@ -0,0 +1,64 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"os"
+)
+
+type Config struct {
+}
+
+type dbConfig struct {
+	dbHost     string
+	dbPort     string
+	dbName     string
+	dbUserName string
+	dbPassword string
+}
+type targetDbConfig struct {
+	targetDbHost     string
+	targetDbPort     string
+	targetDbUserName string
+	targetDbPassword string
+	targetDbName     string
+}
+
+func getDbConfig(cmd *cobra.Command) *dbConfig {
+	//Set env
+	utils.GetEnv(cmd, "dbname", "DB_NAME")
+	dConf := dbConfig{}
+	dConf.dbHost = os.Getenv("DB_HOST")
+	dConf.dbPort = os.Getenv("DB_PORT")
+	dConf.dbName = os.Getenv("DB_NAME")
+	dConf.dbUserName = os.Getenv("DB_USERNAME")
+	dConf.dbPassword = os.Getenv("DB_PASSWORD")
+
+	err := utils.CheckEnvVars(dbHVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for database are set")
+		utils.Fatal("Error checking environment variables: %s", err)
+	}
+	return &dConf
+}
+func getTargetDbConfig() *targetDbConfig {
+	tdbConfig := targetDbConfig{}
+	tdbConfig.targetDbHost = os.Getenv("TARGET_DB_HOST")
+	tdbConfig.targetDbPort = os.Getenv("TARGET_DB_PORT")
+	tdbConfig.targetDbName = os.Getenv("TARGET_DB_NAME")
+	tdbConfig.targetDbUserName = os.Getenv("TARGET_DB_USERNAME")
+	tdbConfig.targetDbPassword = os.Getenv("TARGET_DB_PASSWORD")
+
+	err := utils.CheckEnvVars(tdbRVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for the target database are set")
+		utils.Fatal("Error checking target database environment variables: %s", err)
+	}
+	return &tdbConfig
+}
--- a/pkg/encrypt.go
+++ b/pkg/encrypt.go
@@ -0,0 +1,63 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"github.com/jkaninda/mysql-bkup/utils"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+func Decrypt(inputFile string, passphrase string) error {
+	utils.Info("Decrypting backup file: " + inputFile + " ...")
+	//Create gpg home dir
+	err := utils.MakeDir(gpgHome)
+	if err != nil {
+		return err
+	}
+	utils.SetEnv("GNUPGHOME", gpgHome)
+	cmd := exec.Command("gpg", "--batch", "--passphrase", passphrase, "--output", RemoveLastExtension(inputFile), "--decrypt", inputFile)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err = cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	utils.Info("Backup file decrypted successful!")
+	return nil
+}
+
+func Encrypt(inputFile string, passphrase string) error {
+	utils.Info("Encrypting backup...")
+	//Create gpg home dir
+	err := utils.MakeDir(gpgHome)
+	if err != nil {
+		return err
+	}
+	utils.SetEnv("GNUPGHOME", gpgHome)
+	cmd := exec.Command("gpg", "--batch", "--passphrase", passphrase, "--symmetric", "--cipher-algo", algorithm, inputFile)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	err = cmd.Run()
+	if err != nil {
+		return err
+	}
+
+	utils.Info("Backup file encrypted successful!")
+	return nil
+}
+
+func RemoveLastExtension(filename string) string {
+	if idx := strings.LastIndex(filename, "."); idx != -1 {
+		return filename[:idx]
+	}
+	return filename
+}
--- a/pkg/helper.go
+++ b/pkg/helper.go
@@ -0,0 +1,127 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+)
+
+func copyToTmp(sourcePath string, backupFileName string) {
+	//Copy backup from storage to /tmp
+	err := utils.CopyFile(filepath.Join(sourcePath, backupFileName), filepath.Join(tmpPath, backupFileName))
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error copying file %s %s", backupFileName, err))
+
+	}
+}
+func moveToBackup(backupFileName string, destinationPath string) {
+	//Copy backup from tmp folder to storage destination
+	err := utils.CopyFile(filepath.Join(tmpPath, backupFileName), filepath.Join(destinationPath, backupFileName))
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error copying file %s %s", backupFileName, err))
+
+	}
+	//Delete backup file from tmp folder
+	err = utils.DeleteFile(filepath.Join(tmpPath, backupFileName))
+	if err != nil {
+		fmt.Println("Error deleting file:", err)
+
+	}
+	utils.Done("Database has been backed up and copied to %s", filepath.Join(destinationPath, backupFileName))
+}
+func deleteOldBackup(retentionDays int) {
+	utils.Info("Deleting old backups...")
+	storagePath = os.Getenv("STORAGE_PATH")
+	// Define the directory path
+	backupDir := storagePath + "/"
+	// Get current time
+	currentTime := time.Now()
+	// Delete file
+	deleteFile := func(filePath string) error {
+		err := os.Remove(filePath)
+		if err != nil {
+			utils.Fatal(fmt.Sprintf("Error: %s", err))
+		} else {
+			utils.Done("File  %s  has been deleted successfully", filePath)
+		}
+		return err
+	}
+
+	// Walk through the directory and delete files modified more than specified days ago
+	err := filepath.Walk(backupDir, func(filePath string, fileInfo os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// Check if it's a regular file and if it was modified more than specified days ago
+		if fileInfo.Mode().IsRegular() {
+			timeDiff := currentTime.Sub(fileInfo.ModTime())
+			if timeDiff.Hours() > 24*float64(retentionDays) {
+				err := deleteFile(filePath)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		utils.Fatal(fmt.Sprintf("Error: %s", err))
+		return
+	}
+	utils.Done("Deleting old backups...done")
+
+}
+func deleteTemp() {
+	utils.Info("Deleting %s ...", tmpPath)
+	err := filepath.Walk(tmpPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		// Check if the current item is a file
+		if !info.IsDir() {
+			// Delete the file
+			err = os.Remove(path)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		utils.Error("Error deleting files: %v", err)
+	} else {
+		utils.Info("Deleting %s ... done", tmpPath)
+	}
+}
+
+// TestDatabaseConnection  tests the database connection
+func testDatabaseConnection(db *dbConfig) {
+
+	utils.Info("Connecting to %s database ...", db.dbName)
+
+	cmd := exec.Command("mysql", "-h", db.dbHost, "-P", db.dbPort, "-u", db.dbUserName, "--password="+db.dbPassword, db.dbName, "-e", "quit")
+
+	// Capture the output
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = &out
+	err := cmd.Run()
+	if err != nil {
+		utils.Error("Error testing database connection: %v\nOutput: %s", err, out.String())
+		os.Exit(1)
+
+	}
+	utils.Info("Successfully connected to %s database", db.dbName)
+
+}
--- a/pkg/migrate.go
+++ b/pkg/migrate.go
@@ -0,0 +1,40 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"fmt"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"time"
+)
+
+func StartMigration(cmd *cobra.Command) {
+	utils.Welcome()
+	utils.Info("Starting database migration...")
+	//Get DB config
+	dbConf = getDbConfig(cmd)
+	targetDbConf = getTargetDbConfig()
+
+	//Defining the target database variables
+	newDbConfig := dbConfig{}
+	newDbConfig.dbHost = targetDbConf.targetDbHost
+	newDbConfig.dbPort = targetDbConf.targetDbPort
+	newDbConfig.dbName = targetDbConf.targetDbName
+	newDbConfig.dbUserName = targetDbConf.targetDbUserName
+	newDbConfig.dbPassword = targetDbConf.targetDbPassword
+
+	//Generate file name
+	backupFileName := fmt.Sprintf("%s_%s.sql", dbConf.dbName, time.Now().Format("20060102_150405"))
+	//Backup source Database
+	BackupDatabase(dbConf, backupFileName, true)
+	//Restore source database into target database
+	utils.Info("Restoring [%s] database into [%s] database...", dbConf.dbName, targetDbConf.targetDbName)
+	RestoreDatabase(&newDbConfig, backupFileName)
+	utils.Info("[%s] database has been restored into [%s] database", dbConf.dbName, targetDbConf.targetDbName)
+	utils.Info("Database migration completed.")
+}
--- a/pkg/restore.go
+++ b/pkg/restore.go
@@ -0,0 +1,132 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"fmt"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"github.com/spf13/cobra"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+func StartRestore(cmd *cobra.Command) {
+	utils.Welcome()
+	//Set env
+	utils.SetEnv("STORAGE_PATH", storagePath)
+
+	//Get flag value and set env
+	s3Path := utils.GetEnv(cmd, "path", "AWS_S3_PATH")
+	remotePath := utils.GetEnv(cmd, "path", "SSH_REMOTE_PATH")
+	storage = utils.GetEnv(cmd, "storage", "STORAGE")
+	file = utils.GetEnv(cmd, "file", "FILE_NAME")
+	executionMode, _ = cmd.Flags().GetString("mode")
+	bucket := utils.GetEnvVariable("AWS_S3_BUCKET_NAME", "BUCKET_NAME")
+	dbConf = getDbConfig(cmd)
+
+	switch storage {
+	case "s3":
+		restoreFromS3(dbConf, file, bucket, s3Path)
+	case "local":
+		utils.Info("Restore database from local")
+		copyToTmp(storagePath, file)
+		RestoreDatabase(dbConf, file)
+	case "ssh":
+		restoreFromRemote(dbConf, file, remotePath)
+	case "ftp":
+		utils.Fatal("Restore from FTP is not yet supported")
+	default:
+		utils.Info("Restore database from local")
+		copyToTmp(storagePath, file)
+		RestoreDatabase(dbConf, file)
+	}
+}
+
+func restoreFromS3(db *dbConfig, file, bucket, s3Path string) {
+	utils.Info("Restore database from s3")
+	err := utils.DownloadFile(tmpPath, file, bucket, s3Path)
+	if err != nil {
+		utils.Fatal("Error download file from s3 %s %v", file, err)
+	}
+	RestoreDatabase(db, file)
+}
+func restoreFromRemote(db *dbConfig, file, remotePath string) {
+	utils.Info("Restore database from remote server")
+	err := CopyFromRemote(file, remotePath)
+	if err != nil {
+		utils.Fatal("Error download file from remote server: %s %v  ", filepath.Join(remotePath, file), err)
+	}
+	RestoreDatabase(db, file)
+}
+
+// RestoreDatabase restore database
+func RestoreDatabase(db *dbConfig, file string) {
+	gpgPassphrase := os.Getenv("GPG_PASSPHRASE")
+	if file == "" {
+		utils.Fatal("Error, file required")
+	}
+
+	err := utils.CheckEnvVars(dbHVars)
+	if err != nil {
+		utils.Error("Please make sure all required environment variables for database are set")
+		utils.Fatal("Error checking environment variables: %s", err)
+	}
+
+	extension := filepath.Ext(fmt.Sprintf("%s/%s", tmpPath, file))
+	if extension == ".gpg" {
+		if gpgPassphrase == "" {
+			utils.Fatal("Error: GPG passphrase is required, your file seems to be a GPG file.\nYou need to provide GPG keys. GPG_PASSPHRASE environment variable is required.")
+
+		} else {
+			//Decrypt file
+			err := Decrypt(filepath.Join(tmpPath, file), gpgPassphrase)
+			if err != nil {
+				utils.Fatal("Error decrypting file %s %v", file, err)
+			}
+			//Update file name
+			file = RemoveLastExtension(file)
+		}
+
+	}
+
+	if utils.FileExists(fmt.Sprintf("%s/%s", tmpPath, file)) {
+		testDatabaseConnection(db)
+		utils.Info("Restoring database...")
+
+		extension := filepath.Ext(fmt.Sprintf("%s/%s", tmpPath, file))
+		// Restore from compressed file / .sql.gz
+		if extension == ".gz" {
+			str := "zcat " + fmt.Sprintf("%s/%s", tmpPath, file) + " | mysql -h " + db.dbHost + " -P " + db.dbPort + " -u " + db.dbUserName + " --password=" + db.dbPassword + " " + db.dbName
+			_, err := exec.Command("bash", "-c", str).Output()
+			if err != nil {
+				utils.Fatal("Error, in restoring the database  %v", err)
+			}
+			utils.Info("Restoring database... done")
+			utils.Done("Database has been restored")
+			//Delete temp
+			deleteTemp()
+
+		} else if extension == ".sql" {
+			//Restore from sql file
+			str := "cat " + fmt.Sprintf("%s/%s", tmpPath, file) + " | mysql -h " + db.dbHost + " -P " + db.dbPort + " -u " + db.dbUserName + " --password=" + db.dbPassword + " " + db.dbName
+			_, err := exec.Command("bash", "-c", str).Output()
+			if err != nil {
+				utils.Fatal(fmt.Sprintf("Error in restoring the database %s", err))
+			}
+			utils.Info("Restoring database... done")
+			utils.Done("Database has been restored")
+			//Delete temp
+			deleteTemp()
+		} else {
+			utils.Fatal(fmt.Sprintf("Unknown file extension %s", extension))
+		}
+
+	} else {
+		utils.Fatal(fmt.Sprintf("File not found in %s", fmt.Sprintf("%s/%s", tmpPath, file)))
+	}
+}
--- a/pkg/scp.go
+++ b/pkg/scp.go
@@ -0,0 +1,121 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/bramvdbogaerde/go-scp"
+	"github.com/bramvdbogaerde/go-scp/auth"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"golang.org/x/crypto/ssh"
+	"os"
+	"path/filepath"
+)
+
+func CopyToRemote(fileName, remotePath string) error {
+	sshUser := os.Getenv("SSH_USER")
+	sshPassword := os.Getenv("SSH_PASSWORD")
+	sshHostName := os.Getenv("SSH_HOST_NAME")
+	sshPort := os.Getenv("SSH_PORT")
+	sshIdentifyFile := os.Getenv("SSH_IDENTIFY_FILE")
+
+	err := utils.CheckEnvVars(sshHVars)
+	if err != nil {
+		utils.Error("Error checking environment variables: %s", err)
+		os.Exit(1)
+	}
+
+	clientConfig, _ := auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+	if sshIdentifyFile != "" && utils.FileExists(sshIdentifyFile) {
+		clientConfig, _ = auth.PrivateKey(sshUser, sshIdentifyFile, ssh.InsecureIgnoreHostKey())
+
+	} else {
+		if sshPassword == "" {
+			return errors.New("SSH_PASSWORD environment variable is required if SSH_IDENTIFY_FILE is empty")
+		}
+		utils.Warn("Accessing the remote server using password, password is not recommended")
+		clientConfig, _ = auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+
+	}
+	// Create a new SCP client
+	client := scp.NewClient(fmt.Sprintf("%s:%s", sshHostName, sshPort), &clientConfig)
+
+	// Connect to the remote server
+	err = client.Connect()
+	if err != nil {
+		return errors.New("Couldn't establish a connection to the remote server")
+	}
+
+	// Open a file
+	file, _ := os.Open(filepath.Join(tmpPath, fileName))
+
+	// Close client connection after the file has been copied
+	defer client.Close()
+	// Close the file after it has been copied
+	defer file.Close()
+	// the context can be adjusted to provide time-outs or inherit from other contexts if this is embedded in a larger application.
+	err = client.CopyFromFile(context.Background(), *file, filepath.Join(remotePath, fileName), "0655")
+	if err != nil {
+		fmt.Println("Error while copying file ")
+		return err
+	}
+	return nil
+}
+
+func CopyFromRemote(fileName, remotePath string) error {
+	sshUser := os.Getenv("SSH_USER")
+	sshPassword := os.Getenv("SSH_PASSWORD")
+	sshHostName := os.Getenv("SSH_HOST_NAME")
+	sshPort := os.Getenv("SSH_PORT")
+	sshIdentifyFile := os.Getenv("SSH_IDENTIFY_FILE")
+
+	err := utils.CheckEnvVars(sshHVars)
+	if err != nil {
+		utils.Error("Error checking environment variables\n: %s", err)
+		os.Exit(1)
+	}
+
+	clientConfig, _ := auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+	if sshIdentifyFile != "" && utils.FileExists(sshIdentifyFile) {
+		clientConfig, _ = auth.PrivateKey(sshUser, sshIdentifyFile, ssh.InsecureIgnoreHostKey())
+
+	} else {
+		if sshPassword == "" {
+			return errors.New("SSH_PASSWORD environment variable is required if SSH_IDENTIFY_FILE is empty\n")
+		}
+		utils.Warn("Accessing the remote server using password, password is not recommended")
+		clientConfig, _ = auth.PasswordKey(sshUser, sshPassword, ssh.InsecureIgnoreHostKey())
+
+	}
+	// Create a new SCP client
+	client := scp.NewClient(fmt.Sprintf("%s:%s", sshHostName, sshPort), &clientConfig)
+
+	// Connect to the remote server
+	err = client.Connect()
+	if err != nil {
+		return errors.New("Couldn't establish a connection to the remote server\n")
+	}
+	// Close client connection after the file has been copied
+	defer client.Close()
+	file, err := os.OpenFile(filepath.Join(tmpPath, fileName), os.O_RDWR|os.O_CREATE, 0777)
+	if err != nil {
+		fmt.Println("Couldn't open the output file")
+	}
+	defer file.Close()
+
+	// the context can be adjusted to provide time-outs or inherit from other contexts if this is embedded in a larger application.
+	err = client.CopyFromRemote(context.Background(), file, filepath.Join(remotePath, fileName))
+
+	if err != nil {
+		fmt.Println("Error while copying file ", err)
+		return err
+	}
+	return nil
+
+}
--- a/pkg/scripts.go
+++ b/pkg/scripts.go
@@ -0,0 +1,71 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+import (
+	"fmt"
+	"github.com/jkaninda/mysql-bkup/utils"
+	"os"
+	"os/exec"
+)
+
+func CreateCrontabScript(disableCompression bool, storage string) {
+	//task := "/usr/local/bin/backup_cron.sh"
+	touchCmd := exec.Command("touch", backupCronFile)
+	if err := touchCmd.Run(); err != nil {
+		utils.Fatal("Error creating file %s: %v\n", backupCronFile, err)
+	}
+	var disableC = ""
+	if disableCompression {
+		disableC = "--disable-compression"
+	}
+
+	scriptContent := fmt.Sprintf(`#!/usr/bin/env bash
+set -e
+/usr/local/bin/mysql-bkup backup --dbname %s --port %s --storage %s %v
+`, os.Getenv("DB_NAME"), os.Getenv("DB_PORT"), storage, disableC)
+
+	if err := utils.WriteToFile(backupCronFile, scriptContent); err != nil {
+		utils.Fatal("Error writing to %s: %v\n", backupCronFile, err)
+	}
+
+	chmodCmd := exec.Command("chmod", "+x", "/usr/local/bin/backup_cron.sh")
+	if err := chmodCmd.Run(); err != nil {
+		utils.Fatal("Error changing permissions of %s: %v\n", backupCronFile, err)
+	}
+
+	lnCmd := exec.Command("ln", "-s", "/usr/local/bin/backup_cron.sh", "/usr/local/bin/backup_cron")
+	if err := lnCmd.Run(); err != nil {
+		utils.Fatal("Error creating symbolic link: %v\n", err)
+
+	}
+
+	touchLogCmd := exec.Command("touch", cronLogFile)
+	if err := touchLogCmd.Run(); err != nil {
+		utils.Fatal("Error creating file %s: %v\n", cronLogFile, err)
+	}
+
+	cronJob := "/etc/cron.d/backup_cron"
+	touchCronCmd := exec.Command("touch", cronJob)
+	if err := touchCronCmd.Run(); err != nil {
+		utils.Fatal("Error creating file %s: %v\n", cronJob, err)
+	}
+
+	cronContent := fmt.Sprintf(`%s root exec /bin/bash -c ". /run/supervisord.env; /usr/local/bin/backup_cron.sh >> %s"
+`, os.Getenv("BACKUP_CRON_EXPRESSION"), cronLogFile)
+
+	if err := utils.WriteToFile(cronJob, cronContent); err != nil {
+		utils.Fatal("Error writing to %s: %v\n", cronJob, err)
+	}
+	utils.ChangePermission("/etc/cron.d/backup_cron", 0644)
+
+	crontabCmd := exec.Command("crontab", "/etc/cron.d/backup_cron")
+	if err := crontabCmd.Run(); err != nil {
+		utils.Fatal("Error updating crontab: ", err)
+	}
+	utils.Info("Backup job created.")
+}
--- a/pkg/var.go
+++ b/pkg/var.go
@@ -0,0 +1,49 @@
+// Package pkg /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package pkg
+
+const cronLogFile = "/var/log/mysql-bkup.log"
+const tmpPath = "/tmp/backup"
+const backupCronFile = "/usr/local/bin/backup_cron.sh"
+const algorithm = "aes256"
+const gpgHome = "gnupg"
+const gpgExtension = "gpg"
+
+var (
+	storage            = "local"
+	file               = ""
+	executionMode      = "default"
+	storagePath        = "/backup"
+	disableCompression = false
+	encryption         = false
+)
+
+// dbHVars Required environment variables for database
+var dbHVars = []string{
+	"DB_HOST",
+	"DB_PASSWORD",
+	"DB_USERNAME",
+	"DB_NAME",
+}
+var tdbRVars = []string{
+	"TARGET_DB_HOST",
+	"TARGET_DB_PORT",
+	"TARGET_DB_NAME",
+	"TARGET_DB_USERNAME",
+	"TARGET_DB_PASSWORD",
+}
+
+var dbConf *dbConfig
+var targetDbConf *targetDbConfig
+
+// sshHVars Required environment variables for SSH remote server storage
+var sshHVars = []string{
+	"SSH_USER",
+	"SSH_REMOTE_PATH",
+	"SSH_HOST_NAME",
+	"SSH_PORT",
+}
--- a/src/docker/Dockerfile
+++ b/src/docker/Dockerfile
@@ -1,35 +0,0 @@
-FROM ubuntu:24.04
-ENV DB_HOST=""
-ENV DB_NAME=""
-ENV DB_USERNAME=""
-ENV DB_PASSWORD=""
-ENV DB_PORT="3306"
-ENV DESTINATION=local
-ENV STORAGE=local
-ENV SOURCE=local
-ENV BUCKETNAME=""
-ENV ACCESS_KEY=""
-ENV SECRET_KEY=""
-ENV S3_ENDPOINT=https://s3.amazonaws.com
-ARG DEBIAN_FRONTEND=noninteractive
-ENV VERSION="1.0"
-
-RUN apt-get update -qq
-RUN apt-get install build-essential libcurl4-openssl-dev libxml2-dev mime-support -y
-RUN apt install s3fs mysql-client -y
-# Clear cache
-RUN apt-get clean && rm -rf /var/lib/apt/lists/*
-
-RUN mkdir /s3mnt
-RUN mkdir /tmp/s3cache
-RUN chmod 777 /s3mnt
-RUN chmod 777 /tmp/s3cache
-
-COPY src/mysql_bkup.sh /usr/local/bin/
-RUN chmod +x /usr/local/bin/mysql_bkup.sh
-
-RUN ln -s /usr/local/bin/mysql_bkup.sh /usr/local/bin/mysql_bkup
-RUN ln -s /usr/local/bin/mysql_bkup.sh /usr/local/bin/bkup
-
-RUN mkdir /backup
-WORKDIR /backup
--- a/src/mysql_bkup.sh
+++ b/src/mysql_bkup.sh
@@ -1,199 +0,0 @@
-#!/bin/sh 
-set -e
-TIME=$(date +%Y%m%d_%H%M%S)
-MY_SQL_DUMP=/usr/bin/mysqldump
-arg0=$(basename "$0" .sh)
-blnk=$(echo "$arg0" | sed 's/./ /g')
-export OPERATION=backup
-export STORAGE=local
-export STORAGE_PATH=/backup
-export S3_PATH=/mysql-bkup
-export TIMEOUT=60
-export FILE_COMPRESION=true
-usage_info()
-{
-    echo "Usage: \\"
-    echo "     $blnk Backup: mysql_bkup -o backup -d s3 \\"
-    echo "     $blnk Restore: mysql_bkup -o restore -s s3 -f my_db.sql \\"
-    echo "     $blnk [-o|--operation] [{-f|--file} ] [{-s|--storage} ] [{-h|--help} ] \\"
-
-}
-version_info()
-{
-   echo "Version: $VERSION"
-   exit 0
-}
-usage()
-{
-    exec 1>2   # Send standard output to standard error
-    usage_info
-    exit 0
-}
-
-error()
-{
-    echo "$arg0: $*" >&2
-    exit 0
-}
-
-help()
-{
-    echo
-    echo "  -o |--operation         -- Set operation (default: backup)"
-    echo "  -s |--storage           -- Set storage (default: local)"
-    echo "  -f |--file              -- Set file name "
-    echo "     |--path              -- Set s3 path, without file name"
-    echo "  -d |--dbname            -- Set database name "
-    echo "  -p |--port              -- Set database port (default: 3306)"
-    echo "  -t |--timeout           -- Set timeout (default: 120s)"
-    echo "  -h |--help              -- Print this help message and exit"
-    echo "  -V |--version           -- Print version information and exit"
-    exit 0
-}
-
-flags()
-{
-    while test $# -gt 0
-    do
-        case "$1" in
-        (-o|--operation)
-            shift
-            [ $# = 0 ] && error "No operation specified - restore or backup"
-            export OPERATION="$1"
-            shift;;
-        (-d|--dbname)
-            shift
-            [ $# = 0 ] && error "No database name specified"
-            export DB_NAME="$1"
-            shift;;
-        (-s|--storage)
-            shift
-            [ $# = 0 ] && error "No storage specified - local or s3 | default local"
-            export STORAGE="$1"
-            shift;;
-        (-f|--file)
-            shift
-            [ $# = 0 ] && error "No file specified - file to restore"
-            export FILE_NAME="$1"
-            shift;;
-        (--path)
-            shift
-            [ $# = 0 ] && error "No s3 path specified - s3 path without file name"
-            export S3_PATH="$1"
-            shift;;
-        (-db|--database)
-            shift
-            [ $# = 0 ] && error "No database name specified"
-            export DB_NAME="$1"
-            shift;;
-        (-p|--port)
-            shift
-            [ $# = 0 ] && error "No database name specified"
-            export DB_PORT="$1"
-            shift;;
-        (-t|--timeout)
-            shift
-            [ $# = 0 ] && error "No timeout specified"
-            export TIMEOUT="$1"
-            shift;;   
-        (-h|--help)
-            help;;
-        (-V|--version)
-           version_info;;
-        (--)
-           help;;
-        (*) usage;;
-        esac
-    done
-}
-
-backup()
-{
- if [ -z "${DB_HOST}"] ||  [ -z "${DB_NAME}"] ||  [ -z "${DB_USERNAME}"] ||  [ -z "${DB_PASSWORD}"]; then
-   echo "Please make sure all required options are set "
-else
-      ## Test database connection
-      mysql -h ${DB_HOST} -P ${DB_PORT} -u ${DB_USERNAME} --password=${DB_PASSWORD} ${DB_NAME} -e"quit"
-      
-      ## Backup database
-      mysqldump -h ${DB_HOST} -P ${DB_PORT} -u ${DB_USERNAME} --password=${DB_PASSWORD} ${DB_NAME} | gzip > ${STORAGE_PATH}/${DB_NAME}_${TIME}.sql.gz
-      echo "Database has been saved"
-fi
-exit 0
-}
-
-restore()
-{
-if [ -z "${DB_HOST}" ] ||  [ -z "${DB_NAME}" ] ||  [ -z "${DB_USERNAME}" ] || [ -z "${DB_PASSWORD}" ]; then
-   echo "Please make sure all required options are set "
-else
-    ## Restore database
-     if [ -f "${STORAGE_PATH}/$FILE_NAME" ]; then
-         if gzip -t ${STORAGE_PATH}/$FILE_NAME; then
-            zcat ${STORAGE_PATH}/${FILE_NAME} | mysql -h ${DB_HOST} -P ${DB_PORT} -u ${DB_USERNAME} --password=${DB_PASSWORD} ${DB_NAME}
-         else 
-             cat ${STORAGE_PATH}/${FILE_NAME} | mysql -h ${DB_HOST} -P ${DB_PORT} -u ${DB_USERNAME} --password=${DB_PASSWORD} ${DB_NAME}
-           fi
-        echo "Database has been restored"
-      else
-        echo "Error, file not found in ${STORAGE_PATH}/${FILE_NAME}"
-      fi 
-fi
-exit
-}
-
-s3_backup()
-{
- mount_s3
- backup
-}
-
-s3_restore()
-{
-   mount_s3
-   restore
-
-}
-
-mount_s3()
-{
-if [ -z "${ACCESS_KEY}"] ||  [ -z "${SECRET_KEY}"]; then
-echo "Please make sure all environment variables are set "
-echo "BUCKETNAME=$BUCKETNAME \nACCESS_KEY=$nACCESS_KEY \nSECRET_KEY=$SECRET_KEY"
-else
-    echo "$ACCESS_KEY:$SECRET_KEY" | tee /etc/passwd-s3fs
-    chmod 600 /etc/passwd-s3fs
-    echo "Mounting Object storage in /s3mnt .... "
-    if [ -z "$(ls -A /s3mnt)" ]; then
-       s3fs $BUCKETNAME /s3mnt -o passwd_file=/etc/passwd-s3fs -o use_cache=/tmp/s3cache -o allow_other -o url=$S3_ENDPOINT -o use_path_request_style
-       if [ ! -d "/s3mnt$S3_PATH" ]; then
-           mkdir -p /s3mnt$S3_PATH
-        fi 
-    else
-     echo "Object storage already mounted in /s3mnt"
-    fi
-export STORAGE_PATH=/s3mnt$S3_PATH
-fi
-}
-flags "$@"
-# ?
-  if [  $OPERATION != 'backup' ]
-  then
-     if [ $STORAGE != 's3' ]
-     then
-          echo "Restore from local"
-          restore
-      else
-        echo "Restore from s3"
-        s3_restore
-      fi
-  else
-      if [ $STORAGE != 's3' ]
-      then
-          echo "Backup to local destination"
-          backup
-      else
-         echo "Backup to s3 storage"
-         s3_backup
-      fi
-   fi
--- a/utils/constant.go
+++ b/utils/constant.go
@@ -0,0 +1,16 @@
+// Package utils /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package utils
+
+const RestoreExample = "mysql-bkup restore --dbname database --file db_20231219_022941.sql.gz\n" +
+	"bkup restore --dbname database --storage s3 --path /custom-path --file db_20231219_022941.sql.gz"
+const BackupExample = "mysql-bkup backup --dbname database --disable-compression\n" +
+	"mysql-bkup backup --dbname database --storage s3 --path /custom-path --disable-compression"
+
+const MainExample = "mysql-bkup backup --dbname database --disable-compression\n" +
+	"mysql-bkup backup --dbname database --storage s3 --path /custom-path\n" +
+	"mysql-bkup restore --dbname database --file db_20231219_022941.sql.gz"
--- a/utils/logger.go
+++ b/utils/logger.go
@@ -0,0 +1,67 @@
+// Package utils /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package utils
+
+import (
+	"fmt"
+	"os"
+	"time"
+)
+
+var currentTime = time.Now().Format("2006/01/02 15:04:05")
+
+func Info(msg string, args ...any) {
+	formattedMessage := fmt.Sprintf(msg, args...)
+	if len(args) == 0 {
+		fmt.Printf("%s INFO: %s\n", currentTime, msg)
+	} else {
+		fmt.Printf("%s INFO: %s\n", currentTime, formattedMessage)
+	}
+}
+
+// Warn warning message
+func Warn(msg string, args ...any) {
+	formattedMessage := fmt.Sprintf(msg, args...)
+	if len(args) == 0 {
+		fmt.Printf("%s WARN: %s\n", currentTime, msg)
+	} else {
+		fmt.Printf("%s WARN: %s\n", currentTime, formattedMessage)
+	}
+}
+func Error(msg string, args ...any) {
+	formattedMessage := fmt.Sprintf(msg, args...)
+	if len(args) == 0 {
+		fmt.Printf("%s ERROR: %s\n", currentTime, msg)
+	} else {
+		fmt.Printf("%s ERROR: %s\n", currentTime, formattedMessage)
+	}
+}
+func Done(msg string, args ...any) {
+	formattedMessage := fmt.Sprintf(msg, args...)
+	if len(args) == 0 {
+		fmt.Printf("%s INFO: %s\n", currentTime, msg)
+	} else {
+		fmt.Printf("%s INFO: %s\n", currentTime, formattedMessage)
+	}
+}
+
+// Fatal logs an error message and exits the program
+func Fatal(msg string, args ...any) {
+	// Fatal logs an error message and exits the program.
+	formattedMessage := fmt.Sprintf(msg, args...)
+	if len(args) == 0 {
+		fmt.Printf("%s ERROR: %s\n", currentTime, msg)
+		NotifyError(msg)
+	} else {
+		fmt.Printf("%s ERROR: %s\n", currentTime, formattedMessage)
+		NotifyError(formattedMessage)
+
+	}
+
+	os.Exit(1)
+	os.Kill.Signal()
+}
--- a/utils/notification.go
+++ b/utils/notification.go
@@ -0,0 +1,75 @@
+package utils
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+)
+
+func sendMessage(msg string) {
+
+	Info("Sending notification... ")
+	chatId := os.Getenv("TG_CHAT_ID")
+	body, _ := json.Marshal(map[string]string{
+		"chat_id": chatId,
+		"text":    msg,
+	})
+	url := fmt.Sprintf("%s/sendMessage", getTgUrl())
+	// Create an HTTP post request
+	request, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	if err != nil {
+		panic(err)
+	}
+	request.Header.Add("Content-Type", "application/json")
+	client := &http.Client{}
+	response, err := client.Do(request)
+	if err != nil {
+		panic(err)
+	}
+	code := response.StatusCode
+	if code == 200 {
+		Info("Notification has been sent")
+	} else {
+		body, _ := ioutil.ReadAll(response.Body)
+		Error("Message not sent, error: %s", string(body))
+	}
+
+}
+func NotifySuccess(fileName string) {
+	var vars = []string{
+		"TG_TOKEN",
+		"TG_CHAT_ID",
+	}
+
+	//Telegram notification
+	err := CheckEnvVars(vars)
+	if err == nil {
+		message := "PostgreSQL Backup \n" +
+			"Database has been backed up \n" +
+			"Backup name is " + fileName
+		sendMessage(message)
+	}
+}
+func NotifyError(error string) {
+	var vars = []string{
+		"TG_TOKEN",
+		"TG_CHAT_ID",
+	}
+
+	//Telegram notification
+	err := CheckEnvVars(vars)
+	if err == nil {
+		message := "PostgreSQL Backup \n" +
+			"An error occurred during database backup \n" +
+			"Error: " + error
+		sendMessage(message)
+	}
+}
+
+func getTgUrl() string {
+	return fmt.Sprintf("https://api.telegram.org/bot%s", os.Getenv("TG_TOKEN"))
+
+}
--- a/utils/s3.go
+++ b/utils/s3.go
@@ -0,0 +1,175 @@
+// Package utils /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package utils
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/s3"
+	"github.com/aws/aws-sdk-go/service/s3/s3manager"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"time"
+)
+
+// CreateSession creates a new AWS session
+func CreateSession() (*session.Session, error) {
+	// AwsVars Required environment variables for AWS S3 storage
+	var awsVars = []string{
+		"AWS_S3_ENDPOINT",
+		"AWS_S3_BUCKET_NAME",
+		"AWS_ACCESS_KEY",
+		"AWS_SECRET_KEY",
+		"AWS_REGION",
+		"AWS_REGION",
+		"AWS_REGION",
+	}
+
+	endPoint := GetEnvVariable("AWS_S3_ENDPOINT", "S3_ENDPOINT")
+	accessKey := GetEnvVariable("AWS_ACCESS_KEY", "ACCESS_KEY")
+	secretKey := GetEnvVariable("AWS_SECRET_KEY", "SECRET_KEY")
+	_ = GetEnvVariable("AWS_S3_BUCKET_NAME", "BUCKET_NAME")
+
+	region := os.Getenv("AWS_REGION")
+	awsDisableSsl, err := strconv.ParseBool(os.Getenv("AWS_DISABLE_SSL"))
+	if err != nil {
+		Fatal("Unable to parse AWS_DISABLE_SSL env var: %s", err)
+	}
+
+	err = CheckEnvVars(awsVars)
+	if err != nil {
+		Fatal("Error checking environment variables\n: %s", err)
+	}
+	// S3 Config
+	s3Config := &aws.Config{
+		Credentials:      credentials.NewStaticCredentials(accessKey, secretKey, ""),
+		Endpoint:         aws.String(endPoint),
+		Region:           aws.String(region),
+		DisableSSL:       aws.Bool(awsDisableSsl),
+		S3ForcePathStyle: aws.Bool(true),
+	}
+	return session.NewSession(s3Config)
+
+}
+
+// UploadFileToS3 uploads a file to S3 with a given prefix
+func UploadFileToS3(filePath, key, bucket, prefix string) error {
+	sess, err := CreateSession()
+	if err != nil {
+		return err
+	}
+
+	svc := s3.New(sess)
+
+	file, err := os.Open(filepath.Join(filePath, key))
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	fileInfo, err := file.Stat()
+	if err != nil {
+		return err
+	}
+
+	objectKey := filepath.Join(prefix, key)
+
+	buffer := make([]byte, fileInfo.Size())
+	file.Read(buffer)
+	fileBytes := bytes.NewReader(buffer)
+	fileType := http.DetectContentType(buffer)
+
+	_, err = svc.PutObject(&s3.PutObjectInput{
+		Bucket:        aws.String(bucket),
+		Key:           aws.String(objectKey),
+		Body:          fileBytes,
+		ContentLength: aws.Int64(fileInfo.Size()),
+		ContentType:   aws.String(fileType),
+	})
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+func DownloadFile(destinationPath, key, bucket, prefix string) error {
+
+	sess, err := CreateSession()
+	if err != nil {
+		return err
+	}
+	Info("Download backup from S3 storage...")
+	file, err := os.Create(filepath.Join(destinationPath, key))
+	if err != nil {
+		fmt.Println("Failed to create file", err)
+		return err
+	}
+	defer file.Close()
+
+	objectKey := filepath.Join(prefix, key)
+
+	downloader := s3manager.NewDownloader(sess)
+	numBytes, err := downloader.Download(file,
+		&s3.GetObjectInput{
+			Bucket: aws.String(bucket),
+			Key:    aws.String(objectKey),
+		})
+	if err != nil {
+		fmt.Println("Failed to download file", err)
+		return err
+	}
+	Info("Backup downloaded:  %s bytes size %s ", file.Name(), numBytes)
+
+	return nil
+}
+func DeleteOldBackup(bucket, prefix string, retention int) error {
+	sess, err := CreateSession()
+	if err != nil {
+		return err
+	}
+
+	svc := s3.New(sess)
+
+	// Get the current time and the time threshold for 7 days ago
+	now := time.Now()
+	backupRetentionDays := now.AddDate(0, 0, -retention)
+
+	// List objects in the bucket
+	listObjectsInput := &s3.ListObjectsV2Input{
+		Bucket: aws.String(bucket),
+		Prefix: aws.String(prefix),
+	}
+	err = svc.ListObjectsV2Pages(listObjectsInput, func(page *s3.ListObjectsV2Output, lastPage bool) bool {
+		for _, object := range page.Contents {
+			if object.LastModified.Before(backupRetentionDays) {
+				// Object is older than retention days, delete it
+				_, err := svc.DeleteObject(&s3.DeleteObjectInput{
+					Bucket: aws.String(bucket),
+					Key:    object.Key,
+				})
+				if err != nil {
+					log.Printf("Failed to delete object %s: %v", *object.Key, err)
+				} else {
+					fmt.Printf("Deleted object %s\n", *object.Key)
+				}
+			}
+		}
+		return !lastPage
+	})
+	if err != nil {
+		log.Fatalf("Failed to list objects: %v", err)
+	}
+
+	fmt.Println("Finished deleting old files.")
+	return nil
+}
--- a/utils/utils.go
+++ b/utils/utils.go
@@ -0,0 +1,191 @@
+// Package utils /
+/*****
+@author    Jonas Kaninda
+@license   MIT License <https://opensource.org/licenses/MIT>
+@Copyright © 2024 Jonas Kaninda
+**/
+package utils
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"io"
+	"io/fs"
+	"os"
+	"strconv"
+)
+
+func FileExists(filename string) bool {
+	info, err := os.Stat(filename)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return !info.IsDir()
+}
+
+func WriteToFile(filePath, content string) error {
+	file, err := os.Create(filePath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	_, err = file.WriteString(content)
+	return err
+}
+func DeleteFile(filePath string) error {
+	err := os.Remove(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to delete file: %v", err)
+	}
+	return nil
+}
+func CopyFile(src, dst string) error {
+	// Open the source file for reading
+	sourceFile, err := os.Open(src)
+	if err != nil {
+		return fmt.Errorf("failed to open source file: %v", err)
+	}
+	defer sourceFile.Close()
+
+	// Create the destination file
+	destinationFile, err := os.Create(dst)
+	if err != nil {
+		return fmt.Errorf("failed to create destination file: %v", err)
+	}
+	defer destinationFile.Close()
+
+	// Copy the content from source to destination
+	_, err = io.Copy(destinationFile, sourceFile)
+	if err != nil {
+		return fmt.Errorf("failed to copy file: %v", err)
+	}
+
+	// Flush the buffer to ensure all data is written
+	err = destinationFile.Sync()
+	if err != nil {
+		return fmt.Errorf("failed to sync destination file: %v", err)
+	}
+
+	return nil
+}
+func ChangePermission(filePath string, mod int) {
+	if err := os.Chmod(filePath, fs.FileMode(mod)); err != nil {
+		Fatal("Error changing permissions of %s: %v\n", filePath, err)
+	}
+
+}
+func IsDirEmpty(name string) (bool, error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close()
+
+	_, err = f.Readdirnames(1)
+	if err == nil {
+		return false, nil
+	}
+	return true, nil
+}
+
+func GetEnv(cmd *cobra.Command, flagName, envName string) string {
+	value, _ := cmd.Flags().GetString(flagName)
+	if value != "" {
+		err := os.Setenv(envName, value)
+		if err != nil {
+			return value
+		}
+	}
+	return os.Getenv(envName)
+}
+func FlagGetString(cmd *cobra.Command, flagName string) string {
+	value, _ := cmd.Flags().GetString(flagName)
+	if value != "" {
+		return value
+
+	}
+	return ""
+}
+func FlagGetBool(cmd *cobra.Command, flagName string) bool {
+	value, _ := cmd.Flags().GetBool(flagName)
+	return value
+}
+
+func SetEnv(key, value string) {
+
+	err := os.Setenv(key, value)
+	if err != nil {
+		return
+	}
+}
+func GetEnvVariable(envName, oldEnvName string) string {
+	value := os.Getenv(envName)
+	if value == "" {
+		value = os.Getenv(oldEnvName)
+		if value != "" {
+			err := os.Setenv(envName, value)
+			if err != nil {
+				return value
+			}
+			Warn("%s is deprecated, please use %s instead!", oldEnvName, envName)
+
+		}
+	}
+	return value
+}
+func ShowHistory() {
+}
+
+// CheckEnvVars checks if all the specified environment variables are set
+func CheckEnvVars(vars []string) error {
+	missingVars := []string{}
+
+	for _, v := range vars {
+		if os.Getenv(v) == "" {
+			missingVars = append(missingVars, v)
+		}
+	}
+
+	if len(missingVars) > 0 {
+		return fmt.Errorf("missing environment variables: %v", missingVars)
+	}
+
+	return nil
+}
+func Welcome() {
+	fmt.Println()
+	fmt.Println("**********************************")
+	fmt.Println("            MySQL Backup          ")
+	fmt.Println("     @Copyright © 2024 jkaninda    ")
+	fmt.Println("***********************************")
+}
+
+// MakeDir create directory
+func MakeDir(dirPath string) error {
+	err := os.Mkdir(dirPath, 0700)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// MakeDirAll create directory
+func MakeDirAll(dirPath string) error {
+	err := os.MkdirAll(dirPath, 0700)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+func GetIntEnv(envName string) int {
+	val := os.Getenv(envName)
+	if val == "" {
+		return 0
+	}
+	ret, err := strconv.Atoi(val)
+	if err != nil {
+		Error("Error: %v", err)
+	}
+	return ret
+}
Author	SHA1	Message	Date
Jonas Kaninda	4808f093e5	Merge pull request #79 from jkaninda/develop Update version	2024-09-10 23:11:28 +02:00
Jonas Kaninda	c7a03861fe	Update version	2024-09-10 23:10:24 +02:00
Jonas Kaninda	36ec63d522	Merge pull request #78 from jkaninda/develop feat: Add Telegram notification	2024-09-10 23:04:12 +02:00
Jonas Kaninda	0f07de1d83	feat: Add Telegram notification	2024-09-10 23:01:26 +02:00
Jonas Kaninda	ae55839996	Merge pull request #77 from jkaninda/docs docs: update Kubernetes deployment	2024-09-09 07:17:51 +02:00
Jonas Kaninda	a7f7e57a0d	docs: update Kubernetes deployment	2024-09-09 07:17:15 +02:00
Jonas Kaninda	b2ddaec93b	Merge pull request #76 from jkaninda/docs docs: add buy me a coffee link	2024-09-05 22:43:09 +02:00
Jonas Kaninda	b3570d774c	docs: add buy me a coffee link	2024-09-05 22:42:37 +02:00
Jonas Kaninda	38f7e91c03	Merge pull request #75 from jkaninda/develop chore: rename environment variable for database migration operation	2024-09-03 07:06:24 +02:00
Jonas Kaninda	07c2935925	chore: rename environment variable for database migration operation	2024-09-03 06:49:26 +02:00
Jonas Kaninda	f3c5585051	Merge pull request #74 from jkaninda/docs Docs	2024-08-30 21:24:50 +02:00
Jonas Kaninda	7163d030a5	chore: remove dbport from command flag	2024-08-30 21:22:18 +02:00
Jonas Kaninda	a2cec86e73	chore: remove dbport from command flag	2024-08-30 21:21:21 +02:00
Jonas Kaninda	662b73579d	feat: add migrate database from a source to a target databse fix: gpg encrypt permission warning message, update Kubernetes deployment example	2024-08-30 19:58:12 +02:00
Jonas Kaninda	c9f8a32de1	Merge pull request #73 from jkaninda/docs docs: update Kubernetes deployment	2024-08-28 20:35:31 +02:00
Jonas Kaninda	8fb008151c	docs: update Kubernetes deployment	2024-08-28 20:35:01 +02:00
Jonas Kaninda	113c84c885	Merge pull request #72 from jkaninda/docs docs: update readme	2024-08-21 03:53:15 +02:00
Jonas Kaninda	58deb92953	docs: update readme	2024-08-21 03:52:49 +02:00
Jonas Kaninda	c41afb8b57	Merge pull request #71 from jkaninda/docs docs: update readme	2024-08-21 03:51:25 +02:00
Jonas Kaninda	02e51a3933	docs: update readme	2024-08-21 03:50:59 +02:00
Jonas Kaninda	db4061b64b	Merge pull request #70 from jkaninda/docs docs: update readme	2024-08-21 03:49:58 +02:00
Jonas Kaninda	9467b157aa	docs: update reamdme	2024-08-21 03:49:15 +02:00
Jonas Kaninda	c229ebdc9d	Merge pull request #69 from jkaninda/docs docs: fix grammar	2024-08-20 19:21:24 +02:00
Jonas Kaninda	7b701d1740	docs: fix grammar	2024-08-20 19:20:54 +02:00
Jonas Kaninda	ad6f190bad	Merge pull request #68 from jkaninda/docs docs: update readme	2024-08-15 06:06:26 +02:00
Jonas Kaninda	de4dcaaeca	docs: update readme	2024-08-15 06:05:39 +02:00
Jonas Kaninda	17c0a99bda	Merge pull request #67 from jkaninda/develop Develop	2024-08-15 05:02:56 +02:00
Jonas Kaninda	b1c9abf931	Clean up	2024-08-14 22:28:16 +02:00
Jonas Kaninda	a70a893c11	Fix encryption permission issue on Openshift	2024-08-14 22:19:35 +02:00
Jonas Kaninda	243e25f4fb	Fix encryption permission issue on Openshift	2024-08-14 22:19:02 +02:00
Jonas Kaninda	cb0dcf4104	Update docs	2024-08-11 09:49:41 +02:00
Jonas Kaninda	d26d8d31c9	Merge pull request #65 from jkaninda/docs Merge Docs	2024-08-11 09:48:08 +02:00
Jonas Kaninda	71d438ba76	Merge branch 'main' of github.com:jkaninda/mysql-bkup into develop	2024-08-11 09:44:00 +02:00
Jonas Kaninda	a3fc58af96	Add delete /tmp directory after backup or restore and update docs	2024-08-11 09:38:31 +02:00
Jonas Kaninda	08ca6d4a39	Merge pull request #64 from jkaninda/develop docs: update readme	2024-08-10 11:30:53 +02:00
Jonas Kaninda	27b9ab5f36	docs: update readme	2024-08-10 11:29:58 +02:00
Jonas Kaninda	6d6db7061b	Merge pull request #63 from jkaninda/develop Develop	2024-08-10 11:28:06 +02:00
Jonas Kaninda	d90647aae7	Update app version	2024-08-10 11:22:08 +02:00
Jonas Kaninda	5c2c05499f	docs: update example	2024-08-10 11:12:43 +02:00
Jonas Kaninda	88ada6fefd	docs: update example	2024-08-10 11:12:17 +02:00
Jonas Kaninda	e6c8b0923d	Add Docker entrypont, update docs	2024-08-10 10:50:00 +02:00
Jonas Kaninda	59a136039c	Merge pull request #62 from jkaninda/docs docs: update stable version	2024-08-04 23:45:36 +02:00
Jonas Kaninda	db835e81c4	docs: update stable version	2024-08-04 23:44:49 +02:00
Jonas Kaninda	5b05bcbf0c	Merge pull request #61 from jkaninda/docs docs: add Kubernetes restore Job example	2024-08-04 13:38:10 +02:00
Jonas Kaninda	b8277c8464	docs: add Kubernetes restore Job example	2024-08-04 13:37:45 +02:00
Jonas Kaninda	70338b6ae6	Merge pull request #60 from jkaninda/develop Develop	2024-08-04 13:12:50 +02:00
Jonas Kaninda	33b1acf7c0	docs: add Kubernetes restore example	2024-08-04 11:42:07 +02:00
Jonas Kaninda	9a4d02f648	fix: Fix AWS S3 and SSH backup in scheduled mode on Docker and Docker Swarm mode	2024-08-04 11:30:28 +02:00
Jonas Kaninda	1e06600c43	fix: Fix AWS S3 and SSH backup in scheduled mode on Docker and Docker Swarm mode	2024-08-04 11:30:03 +02:00
Jonas Kaninda	365ab8dfff	Merge pull request #59 from jkaninda/develop Develop	2024-08-04 01:43:49 +02:00
Jonas Kaninda	e4ca97b99e	Fix log	2024-08-04 01:42:51 +02:00
Jonas Kaninda	ae7eb7a159	Fix log, add verification of required environment	2024-08-04 01:36:22 +02:00
Jonas Kaninda	204f66badf	Merge pull request #58 from jkaninda/develop fix: fix github action by getting tag name	2024-08-03 16:23:46 +02:00
Jonas Kaninda	e0b40ed433	fix: fix github action by getting tag name	2024-08-03 16:23:08 +02:00
Jonas Kaninda	07d717fad2	Merge pull request #57 from jkaninda/v1.0 docs: update readme	2024-08-03 16:15:08 +02:00
Jonas Kaninda	3bf4911dee	docs: update readme	2024-08-03 16:14:34 +02:00
Jonas Kaninda	0b34a835f7	Merge pull request #56 from jkaninda/v1.0 docs: update readme	2024-08-03 16:09:33 +02:00
Jonas Kaninda	22bf95e6ca	docs: update readme	2024-08-03 16:08:24 +02:00
Jonas Kaninda	445a104943	Merge pull request #55 from jkaninda/v1.0 Add SSH storage, add database backup encrypt and decrypt	2024-08-03 16:05:55 +02:00
Jonas Kaninda	caeba955c5	Add SSH storage, add database backup encrypt and decrypt	2024-08-03 16:03:17 +02:00
Jonas Kaninda	d906de6b54	Merge pull request #54 from jkaninda/develop Add maintaining log in scheduled mode	2024-07-28 22:56:59 +02:00
Jonas Kaninda	c8e68af09f	Add maintaining log in scheduled mode	2024-07-28 22:54:31 +02:00
Jonas Kaninda	082ef09500	Merge pull request #53 from jkaninda/develop docs: add supported extensions to the doc	2024-02-25 21:35:33 +01:00
Jonas Kaninda	2e61054334	docs: add suported extensions to the doc	2024-02-25 21:35:05 +01:00
Jonas Kaninda	f394f28357	Merge pull request #52 from jkaninda/develop refactor: clean up code	2024-02-25 14:39:03 +01:00
Jonas Kaninda	d8867a9baf	refactor: clean up code	2024-02-25 14:38:32 +01:00
Jonas Kaninda	6ed9ff0a31	Merge pull request #51 from jkaninda/develop refactor: refactoring of code	2024-02-20 07:58:08 +01:00
Jonas Kaninda	a4c37e1a4b	refactor: refactoring of code	2024-02-20 07:57:21 +01:00
Jonas Kaninda	c6930a00ba	Merge pull request #50 from jkaninda/develop refactor: refactoring of code, improvement of deleteOldBackup function	2024-02-18 13:29:01 +01:00
Jonas Kaninda	00f2fca8e4	refactor: refactoring of code, improvement of deleteOldBackup function	2024-02-18 13:27:54 +01:00
Jonas Kaninda	9588c5bcee	Merge pull request #49 from jkaninda/develop Develop	2024-02-17 18:25:37 +01:00
Jonas Kaninda	e0457a4ed8	refactor: clean up code	2024-02-17 18:24:45 +01:00
Jonas Kaninda	d3efa3fc05	chore: update docker tag version	2024-02-17 18:23:27 +01:00
Jonas Kaninda	7bcde78136	feat: add backup prune, to delete old backup	2024-02-17 18:17:41 +01:00
Jonas Kaninda	b95601ab57	Merge pull request #48 from jkaninda/develop chore: rename env variable in Dockerfile	2024-01-22 21:19:44 +01:00
Jonas Kaninda	facd57e2cd	chore: rename env variable in Dockerfile	2024-01-22 21:18:51 +01:00
Jonas Kaninda	2fa7e50485	Merge pull request #47 from jkaninda/develop docs: refactoring of code, update doc	2024-01-21 15:27:14 +01:00
Jonas Kaninda	f53c68cd5c	New release	2024-01-21 15:26:20 +01:00
Jonas Kaninda	902695032c	docs: add more details for env variables	2024-01-21 15:24:44 +01:00
Jonas Kaninda	620801cb99	refactor: refactoring of code, update docs	2024-01-21 15:18:35 +01:00
Jonas Kaninda	e19643ebcb	Merge pull request #46 from jkaninda/refactor docs: update docs	2024-01-20 14:34:36 +01:00
Jonas Kaninda	c87201d08d	docs: update docs	2024-01-20 14:33:58 +01:00
Jonas Kaninda	bf566af4f8	Merge pull request #45 from jkaninda/refactor Refactor	2024-01-20 14:07:32 +01:00
Jonas Kaninda	99ea4e18e5	chore: update app version	2024-01-20 14:06:42 +01:00
Jonas Kaninda	748416af9b	chore: update error message	2024-01-20 14:01:23 +01:00
Jonas Kaninda	bce9512d6a	chore: update error message	2024-01-20 13:59:47 +01:00
Jonas Kaninda	8eff38bdb1	docs: update readme	2024-01-20 13:09:15 +01:00
Jonas Kaninda	c12a6751ae	docs: update readme	2024-01-20 13:07:04 +01:00
Jonas Kaninda	05eda4213a	feat: replace --operation flag by backup and restore command	2024-01-20 13:04:39 +01:00
Jonas Kaninda	a919b161c8	Merge pull request #44 from jkaninda/develop Develop	2024-01-20 04:06:19 +01:00
Jonas Kaninda	4b07a78f29	chore: add mysql_bkup Symlink link	2024-01-20 04:05:28 +01:00
Jonas Kaninda	4a0ad39d70	docs: update readme	2024-01-20 04:02:39 +01:00
Jonas Kaninda	0be493d51f	Merge pull request #43 from jkaninda/develop Merge pull request #42 from jkaninda/develop	2024-01-19 14:53:34 +01:00
Jonas Kaninda	cdb4b2017a	Merge pull request #42 from jkaninda/develop refactor: refactoring of code	2024-01-19 14:52:02 +01:00
Jonas Kaninda	09ba8f8981	Merge pull request #42 from jkaninda/develop refactore: refactoring of code	2024-01-19 14:32:29 +01:00
Jonas Kaninda	2ae78fec57	refactore: refactoring of code	2024-01-19 14:29:37 +01:00
Jonas Kaninda	2cd74167de	Merge pull request #41 from jkaninda/develop chore: clean up code	2024-01-19 14:13:38 +01:00
Jonas Kaninda	aaad8a010c	chore: clean up code	2024-01-19 14:12:05 +01:00
Jonas Kaninda	a086921242	Merge pull request #40 from jkaninda/develop refactor: refactoring of code	2024-01-19 06:57:00 +01:00
Jonas Kaninda	3525a90b93	refactor: refactoring of code	2024-01-19 06:56:19 +01:00
Jonas Kaninda	40f2a2c99d	Merge pull request #39 from jkaninda/develop refactor: clean up code	2024-01-19 06:17:41 +01:00
Jonas Kaninda	3537532d5f	refactor: clean up code	2024-01-19 06:16:51 +01:00
Jonas Kaninda	b98191f586	Merge pull request #38 from jkaninda/develop docs: update readme.md	2024-01-19 05:45:42 +01:00
Jonas Kaninda	502767bb12	docs: update readme.md	2024-01-19 05:45:07 +01:00
Jonas Kaninda	b3b4248fa0	Merge pull request #37 from jkaninda/develop Develop	2024-01-19 05:37:46 +01:00
Jonas Kaninda	8de463ad38	docs: update examples	2024-01-19 05:37:16 +01:00
Jonas Kaninda	2f0375dee3	docs: update examples	2024-01-19 05:36:40 +01:00
Jonas Kaninda	313e4c9525	Merge pull request #36 from jkaninda/develop refactor: move backup, restore, s3fs tasks in pkg folder	2024-01-19 05:31:57 +01:00
Jonas Kaninda	164d8eda77	refactor: move backup, restore, s3fs tasks in pkg folder	2024-01-19 05:31:30 +01:00
Jonas Kaninda	80923885c1	Merge pull request #35 from jkaninda/develop Develop	2024-01-18 19:15:03 +01:00
Jonas Kaninda	078d57fc0d	Refactoring of code	2024-01-18 19:14:19 +01:00
Jonas Kaninda	abd04c0a37	Refactoring of code	2024-01-18 19:13:04 +01:00
Jonas Kaninda	8b7d1576a4	Merge pull request #34 from jkaninda/develop Develop	2024-01-18 15:08:00 +01:00
Jonas Kaninda	452d77f5ee	chore: update README	2024-01-18 15:07:01 +01:00
Jonas Kaninda	4630df0dd6	chore: update README	2024-01-18 15:05:44 +01:00
Jonas Kaninda	5d97ec0a4d	chore: update README	2024-01-18 15:05:25 +01:00
Jonas Kaninda	d9a86ca053	Merge pull request #33 from jkaninda/develop chore: clean project	2024-01-18 14:47:19 +01:00
Jonas Kaninda	380ea59e95	chore: clean project	2024-01-18 14:43:10 +01:00
Jonas Kaninda	af037f195c	Merge pull request #32 from jkaninda/jkaninda-patch-1 Delete .DS_Store	2024-01-18 14:41:55 +01:00
Jonas Kaninda	45d397dfc8	Delete .DS_Store	2024-01-18 14:41:35 +01:00
Jonas Kaninda	72db75b9fb	Merge pull request #31 from jkaninda/go_migration Fix: Docker build file outpout path	2024-01-18 14:29:28 +01:00
Jonas Kaninda	4b1501c095	Fix: Docker build file outpout path	2024-01-18 14:28:41 +01:00
Jonas Kaninda	2823848fd1	Merge pull request #30 from jkaninda/go_migration Migrate project to Go	2024-01-18 14:20:29 +01:00
Jonas Kaninda	d587c18e75	Migrate project to Go	2024-01-18 14:19:27 +01:00
Jonas Kaninda	508ca68366	Merge pull request #29 from jkaninda/develop docs: add recommendation for backup user	2024-01-14 12:35:00 +01:00
Jonas Kaninda	a113b40126	docs: add recommendation for backup user	2024-01-14 12:33:44 +01:00
Jonas Kaninda	1c2a9fccc6	Merge pull request #28 from jkaninda/develop Develop	2024-01-11 19:40:20 +01:00
Jonas Kaninda	c3f17b3d85	feat: add database backup verification	2024-01-11 19:39:50 +01:00
Jonas Kaninda	2a8ad3a6e2	feat: add database backup verification	2024-01-11 19:38:13 +01:00
Jonas Kaninda	cc15452ccf	Merge pull request #27 from jkaninda/develop Refactoring	2023-12-27 21:49:12 +01:00
Jonas Kaninda	bcfc69e7f9	Refactoring	2023-12-27 21:48:24 +01:00
Jonas Kaninda	f3f859ae05	Merge pull request #26 from jkaninda/develop Add database connection testing before running in scheduled mode	2023-12-27 21:29:02 +01:00
Jonas Kaninda	947b9fa888	Add database connection testing before running in scheduled mode	2023-12-27 21:27:24 +01:00
Jonas Kaninda	142a2a2dc3	Merge pull request #25 from jkaninda/develop Update docker compose example files	2023-12-27 07:12:35 +01:00
Jonas Kaninda	548ba17bbb	Update docker compose example files	2023-12-27 07:10:57 +01:00
Jonas Kaninda	b245fe1a11	Merge pull request #24 from jkaninda/develop Update docker compose example files	2023-12-27 06:59:37 +01:00
Jonas Kaninda	0355be59e1	Update docker compose example files	2023-12-27 06:56:06 +01:00
Jonas Kaninda	f5bed16951	Merge pull request #23 from jkaninda/develop Remove volume	2023-12-26 21:54:41 +01:00
Jonas Kaninda	25a32823b7	Remove volume	2023-12-26 21:54:04 +01:00
Jonas Kaninda	498f8ee545	Merge pull request #22 from jkaninda/jkaninda-patch-1 Delete .DS_Store	2023-12-26 21:43:02 +01:00
Jonas Kaninda	ae01fb0edb	Delete .DS_Store	2023-12-26 21:42:27 +01:00
Jonas Kaninda	1f797e019d	Merge pull request #21 from jkaninda/develop Add deployment example	2023-12-26 21:42:09 +01:00
Jonas Kaninda	3ddc00dcbd	Add deployment example	2023-12-26 21:41:43 +01:00
Jonas Kaninda	3d4a245181	Merge pull request #20 from jkaninda/develop Add deployment example	2023-12-26 21:39:55 +01:00
Jonas Kaninda	df5ec79d85	Add deployment example	2023-12-26 21:39:03 +01:00
Jonas Kaninda	53f7a791fa	Merge pull request #19 from jkaninda/develop Update README.md	2023-12-26 21:30:06 +01:00
Jonas Kaninda	31d450e218	Update README.md	2023-12-26 21:28:39 +01:00
Jonas Kaninda	f21f726464	Merge pull request #18 from jkaninda/develop Develop	2023-12-25 03:42:01 +01:00
Jonas Kaninda	f1e116a38b	Update README.md	2023-12-25 03:41:28 +01:00
Jonas Kaninda	5dde6feace	Update action	2023-12-25 02:32:36 +01:00
Jonas Kaninda	4421ca1916	Merge pull request #17 from jkaninda/develop Refactoring of code	2023-12-25 02:32:07 +01:00
Jonas Kaninda	aafe505dc3	Refactoring of code	2023-12-25 02:31:44 +01:00
Jonas Kaninda	7dc7c42c5c	Merge pull request #16 from jkaninda/develop Refactoring of code	2023-12-24 19:27:16 +01:00
Jonas Kaninda	509d9ad3d5	Refactoring of code	2023-12-24 19:25:54 +01:00
Jonas Kaninda	193d46bde6	Merge pull request #15 from jkaninda/develop Change Default cronjob time	2023-12-24 15:01:01 +01:00
Jonas Kaninda	b81c6fc04c	Change Default cronjob time	2023-12-24 14:59:05 +01:00
Jonas Kaninda	d1cbe8bbda	Merge pull request #14 from jkaninda/develop Update version	2023-12-24 14:44:45 +01:00
Jonas Kaninda	275fecd837	Update version	2023-12-24 14:44:15 +01:00
Jonas Kaninda	4e0740ac3b	Merge pull request #13 from jkaninda/develop Merge pull request #12 from jkaninda/scheduled-mode	2023-12-24 12:31:09 +01:00
Jonas Kaninda	4d24713d2d	Merge pull request #12 from jkaninda/scheduled-mode Scheduled mode	2023-12-24 12:30:53 +01:00
Jonas Kaninda	934f5db75f	Merge pull request #11 from jkaninda/scheduled-mode Update README	2023-12-24 12:30:24 +01:00
Jonas Kaninda	d50e7dbdad	Update version	2023-12-24 12:28:54 +01:00
Jonas Kaninda	df899209ac	Merge pull request #10 from jkaninda/scheduled-mode Scheduled mode	2023-12-24 12:19:41 +01:00
Jonas Kaninda	5c559b93fd	Update version	2023-12-24 12:19:12 +01:00
Jonas Kaninda	771d4b7d12	Update version	2023-12-24 12:07:20 +01:00
Jonas Kaninda	a72bf856a2	Update README.md	2023-12-24 12:03:35 +01:00
Jonas Kaninda	4e5f51582f	Update README.md	2023-12-24 12:02:02 +01:00
Jonas Kaninda	65e4b9709c	Update README.md	2023-12-24 12:01:31 +01:00
Jonas Kaninda	6d3f4a2e36	Update README.md	2023-12-24 12:00:50 +01:00
Jonas Kaninda	75cc9dc584	Update README.md	2023-12-24 11:59:00 +01:00
Jonas Kaninda	d7ba0e13a8	Update README.md	2023-12-24 11:54:23 +01:00
Jonas Kaninda	0e65331675	Integret scheduled mode for periodic backups	2023-12-24 11:52:11 +01:00
Jonas Kaninda	acbbc6a7a2	Merge pull request #8 from jkaninda/develop Develop	2023-12-23 22:22:17 +01:00
Jonas Kaninda	902be39db4	Refactoring of code	2023-12-23 22:21:15 +01:00
Jonas Kaninda	a3d34a6600	Clean code	2023-12-23 22:06:56 +01:00