4. Make a backup¶

In this tutorial you will learn how to make a logical backup of your data manually. To learn more about backups, see the Backup and restore section.

Considerations and prerequisites¶

In this tutorial we use the AWS S3 as the backup storage. You need the following S3-related information:

the name of the S3 storage
the name of the S3 bucket
the region - the location of the bucket
the S3 credentials to be used to access the storage.

If you don’t have access to AWS, you can use any S3-compatible storage like MinIO . Also check the list of supported storages.

Also, we will use some files from the Operator repository for setting up backups. So, clone the percona-server-mongodb-operator repository:

$ git clone -b v1.16.2 https://github.com/percona/percona-server-mongodb-operator
$ cd percona-server-mongodb-operator

Note

It is crucial to specify the right branch with -b option while cloning the code on this step. Please be careful.

Configure backup storage¶

Encode S3 credentials, substituting AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY with your real values:

on Linux

$ echo -n 'AWS_ACCESS_KEY_ID' | base64 --wrap=0
$ echo -n 'AWS_SECRET_ACCESS_KEY' | base64 --wrap=0

on MacOS

$ echo -n 'AWS_ACCESS_KEY_ID' | base64 
$ echo -n 'AWS_SECRET_ACCESS_KEY' | base64

Edit the deploy/backup-s3.yaml example Secrets configuration file and specify the following:
- the metadata.name key is the name which you use to refer your Kubernetes Secret
- the base64-encoded S3 credentials
deploy/backup-s3.yaml
```
apiVersion: v1
kind: Secret
metadata:
  name: my-cluster-name-backup-s3
type: Opaque
data:
  AWS_ACCESS_KEY_ID: <YOUR_AWS_ACCESS_KEY_ID>
  AWS_SECRET_ACCESS_KEY: <YOUR_AWS_SECRET_ACCESS_KEY>
```
Create the Secrets object from this yaml file. Specify your namespace instead of the <namespace> placeholder:
```
$ kubectl apply -f deploy/backup-s3.yaml -n <namespace>
```
Update your deploy/cr.yaml configuration. Specify the following parameters in the backups section:
- set the storages.<NAME>.type to s3. Substitute the <NAME> part with some arbitrary name that you will later use to refer this storage when making backups and restores.
- set the storages.<NAME>.s3.credentialsSecret to the name you used to refer your Kubernetes Secret (my-cluster-name-backup-s3 in the previous step).
- specify the S3 bucket name for the storages.<NAME>.s3.bucket option
- specify the region in the storages.<NAME>.s3.region option. Also you can use the storages.<NAME>.s3.prefix option to specify the path (a sub-folder) to the backups inside the S3 bucket. If prefix is not set, backups are stored in the root directory.
```
...
backup:
  ...
  storages:
    s3-us-west:
      type: s3
      s3:
        bucket: "S3-BACKUP-BUCKET-NAME-HERE"
        region: "<AWS_S3_REGION>"
        credentialsSecret: my-cluster-name-backup-s3
  ...
```
If you use a different S3-compatible storage instead of AWS S3, add the endpointURL key in the s3 subsection, which should point to the actual cloud used for backups. This value is specific to the cloud provider. For example, using Google Cloud involves the following endpointUrl:
```
endpointUrl: https://storage.googleapis.com
```
Apply the configuration. Specify your namespace instead of the <namespace> placeholder:
```
$ kubectl apply -f deploy/cr.yaml -n <namespace>
```

Make a logical backup¶

Before you start, verify the backup configuration in the deploy/cr.yaml file:
- the backup.enabled key is set to true
- the backup.storages subsection contains the configured storage.
To make a backup, you need the configuration file. Edit the sample deploy/backup/backup.yaml configuration file and specify the following:
- metadata.name - specify the backup name. You will use this name to restore from this backup
- spec.clusterName - specify the name of your cluster. This is the name you specified when deploying Percona Server for MongoDB.
- spec.storageName - specify the name of your already configured storage.
deploy/backup/backup.yaml
```
apiVersion: psmdb.percona.com/v1
kind: PerconaServerMongoDBBackup
metadata:
  finalizers:
  - delete-backup
  name: backup1
spec:
  clusterName: my-cluster-name
  storageName: s3-us-west
  type: logical
```
Apply the configuration. This instructs the Operator to start a backup. Specify your namespace instead of the <namespace> placeholder:
```
$ kubectl apply -f deploy/backup/backup.yaml -n <namespace>
```

Track the backup progress.

$ kubectl get psmdb-backup -n <namespace>

Output

NAME      CLUSTER           STORAGE      DESTINATION                                     TYPE      STATUS   COMPLETED   AGE
backup1   my-cluster-name   s3-us-west   s3://pg-operator-testing/2023-10-10T16:36:46Z   logical   running                43s

When the status changes to Ready, backup is made.

Troubleshooting¶

You may face issues with the backup. To identify the issue, you can do the following:

View the information about the backup with the following command:

$ kubectl get psmdb-backup <backup-name> -n <namespace> -o yaml

View the backup-agent logs. Use the previous command to find the name of the pod where the backup was made:

$ kubectl logs pod/<pod-name> -c backup-agent -n <namespace>

Congratulations! You have made the first backup manually. Want to learn more about backups? See the Backup and restore section for how to configure point-in-time recovery, enable server-side encryption and how to automatically make backups according to the schedule.

Next steps¶

Monitor the database

Get expert help¶

If you need assistance, visit the community forum for comprehensive and free database knowledge, or contact our Percona Database Experts for professional support and services. Join K8S Squad to benefit from early access to features and “ask me anything” sessions with the Experts.

Community Forum Get a Percona Expert Join K8S Squad

Last update: 2024-09-15