{"id":21140734,"url":"https://github.com/base2services/shelvery-aws-backups","last_synced_at":"2025-04-05T17:04:30.689Z","repository":{"id":26755600,"uuid":"95863077","full_name":"base2Services/shelvery-aws-backups","owner":"base2Services","description":"Automating EBS RDS EC2 backups on lambda","archived":false,"fork":false,"pushed_at":"2025-02-09T23:13:19.000Z","size":392,"stargazers_count":37,"open_issues_count":3,"forks_count":22,"subscribers_count":5,"default_branch":"master","last_synced_at":"2025-04-05T17:04:15.031Z","etag":null,"topics":["amazon","automation","aws","aws-ec2","backup","ebs-backup","ebs-snapshots","ebs-volumes","lambda","python","rds-snapshots","serverless","sysops","utility"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/base2Services.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGES.txt","contributing":null,"funding":null,"license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2017-06-30T07:44:42.000Z","updated_at":"2025-02-09T23:13:23.000Z","dependencies_parsed_at":"2023-12-01T06:23:47.782Z","dependency_job_id":"a835b1de-1f45-458a-b2c6-f37c264710aa","html_url":"https://github.com/base2Services/shelvery-aws-backups","commit_stats":{"total_commits":216,"total_committers":16,"mean_commits":13.5,"dds":0.7175925925925926,"last_synced_commit":"808c6dee03bad0db800f9f9dd93a96bcad39c13a"},"previous_names":[],"tags_count":20,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/base2Services%2Fshelvery-aws-backups","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/base2Services%2Fshelvery-aws-backups/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/base2Services%2Fshelvery-aws-backups/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/base2Services%2Fshelvery-aws-backups/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/base2Services","download_url":"https://codeload.github.com/base2Services/shelvery-aws-backups/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247369953,"owners_count":20927928,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["amazon","automation","aws","aws-ec2","backup","ebs-backup","ebs-snapshots","ebs-volumes","lambda","python","rds-snapshots","serverless","sysops","utility"],"created_at":"2024-11-20T07:17:33.807Z","updated_at":"2025-04-05T17:04:30.661Z","avatar_url":"https://github.com/base2Services.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Shelvery\n\nShelvery creates backups in Amazon Web Services(AWS). It is primarly designed to be run as an AWS Lambda\nFunction, but can be installed as a regular python package, and run as a CLI tool.\n\nShelvery currently supports the following resource types\n\n- EBS volumes\n- EC2 Instances (backups as AMIs)\n- RDS Instances\n- RDS Clusters\n- Redshift Clusters (limited support)\n- DocumentDb\n\n## The Shelvery strategy\n\nShelvery makes a distinction in the space of aws backup tools by *unifying backup and retention periods logic*\nwithin single class called `ShelveryEngine` - `shelvery/engine.py`. It differentiates itself from tooling that only allows\nlinear retention periods (e.g. 28days). Shelvery enables father-son-grandson backup strategies, effectively\nenabling administrators to \"keep the last 7 daily backups, but also the last 12 monthly backups, created on 1st of each month\"\nSupported levels of retention are - daily, weekly (created on Sundays), monthly (created 1st of each month), and yearly\nbackups (created on 1st of January). A general idea is that the more you walk back in past on the timeline,\nless dense backups are.\n\nShelvery also supports backups across multiple accounts without the need to have implemented Organizations.\n\nShelvery *does not* cater for backup restore process.\n\n## Features\n\n- Create and clean EBS Volume backups\n- Create and clean RDS Instance backups\n- Create and clean RDS Cluster backups\n- Create and clean EC2 Instance backups in form of Amazon Machine Images.\n- Create and clean Redshift manual backups\n- Get notified about all operations performed by Shelvery via SNS Topic\n- Share backups with other accounts automatically\n- Copying backups shared by other AWS accounts automatically, enabling a *data bunker* setup\n- Copy backups to disaster recovery AWS regions\n- Multiple levels of configuration, with priorities: Resource tags, Lambda payload, Environment Variables, Config defaults\n\n## Installation and usage\n\n### As Cli\n\nShelvery is published to PyPI as python package, and can be obtained from there. Additionally, you can\nclone this repository and deploy it as lambda.\n\nBelow is an example for installing shelvery within docker `python:3` image, and doing some configuration steps.\n\n```shell\n# run within docker container (preffered, as it has clean python3 install)\ndocker run --rm -it -v $HOME/.aws:/root/.aws -w /shelvery -e 'AWS_DEFAULT_REGION=us-east-1' python:3 bash\n\n# install shelvery package\npip install shelvery\n\n# configure (optional)\nexport shelvery_dr_regions=us-east-2\nexport shelvery_keep_daily_backups=7\n\n# create rds cluster backups\nshelvery ec2ami create_backups\n\n# cleanup rds cluster backups\nshelvery ec2ami clean_backups\n\n# create ebs backups\nshelvery ebs create_backups\n\n# create rds backups\nshelvery rds create_backups\n\n# cleanup ebs backups\nshelvery ebs clean_backups\n\n# cleanup rds backups\nshelvery rds clean_backups\n\n# create rds cluster backups\nshelvery rds_cluster create_backups\n\n# cleanup rds cluster backups\nshelvery rds_cluster clean_backups\n\n# create redshift backups\nshelvery redshift create_backups\n\n# cleanup redshift cluster backups\nshelvery redshift clean_backups\n\n# create documentdb backups\nshelvery docdb create_backups\n\n# cleanup documentdb backups\nshelvery docdb clean_backups\n```\n\n### Deploy as lambda\n\nShelvery can be deployed as a lambda fucntion to AWS using [serverless](www.serverless.com) framework. Serverless takes\ncare of creating the necessary IAM roles. It also adds daily scheduled backups of all supported resources at 1AM UTC,\nand will run backup cleanup at 2AM UTC. Schedules are created as CloudWatch event rules.\nLook at `serverless.yml` file for more details. For this method of installation (that is deployment)\nthere is no python package, and you'll need to clone the project. Below is an example of doing this process within a\n`node` docker container\n\n```text\n$ docker run --rm -it -v $HOME/.aws:/root/.aws -w /src node:latest bash\n\nroot@4b2d6804c8d3:/src#  git clone https://github.com/base2services/shelvery \u0026\u0026 cd shelvery\nCloning into 'shelvery'...\nremote: Counting objects: 114, done.\nremote: Compressing objects: 100% (28/28), done.\nremote: Total 114 (delta 19), reused 24 (delta 12), pack-reused 73\nReceiving objects: 100% (114/114), 38.88 KiB | 0 bytes/s, done.\nResolving deltas: 100% (53/53), done.\nChecking connectivity... done.\nroot@4b2d6804c8d3:/src/shelvery# npm install -g serverless\n/usr/local/bin/slss -\u003e /usr/local/lib/node_modules/serverless/bin/serverless\n/usr/local/bin/serverless -\u003e /usr/local/lib/node_modules/serverless/bin/serverless\n/usr/local/bin/sls -\u003e /usr/local/lib/node_modules/serverless/bin/serverless\n\n\u003e spawn-sync@1.0.15 postinstall /usr/local/lib/node_modules/serverless/node_modules/spawn-sync\n\u003e node postinstall\n\n\n\u003e serverless@1.24.1 postinstall /usr/local/lib/node_modules/serverless\n\u003e node ./scripts/postinstall.js\n\n\n┌───────────────────────────────────────────────────┐\n│          serverless update check failed           │\n│        Try running with sudo or get access        │\n│       to the local update config store via        │\n│ sudo chown -R $USER:$(id -gn $USER) /root/.config │\n└───────────────────────────────────────────────────┘\n+ serverless@1.24.1\nadded 296 packages in 13.228s\n\n\nroot@4b2d6804c8d3:/src/shelvery# sls deploy\nServerless: Packaging service...\nServerless: Excluding development dependencies...\nServerless: Uploading CloudFormation file to S3...\nServerless: Uploading artifacts...\nServerless: Uploading service .zip file to S3 (56.26 KB)...\nServerless: Validating template...\nServerless: Updating Stack...\nServerless: Checking Stack update progress...\n.........\nServerless: Stack update finished...\nService Information\nservice: shelvery\nstage: dev\nregion: us-east-1\nstack: shelvery-dev\napi keys:\n  None\nendpoints:\n  None\nfunctions:\n  shelvery: shelvery-dev-shelvery\nServerless: Removing old service versions...\n\n```\n\n## Delayed operations\n\nSharing a backup with another AWS account, or copying backup to another region is considered\ndelayed operation that should be executed in separate thread, or in case of running on AWS lambda context,\nin another Lambda function invocation. This makes shelvery execution non-linear, in order to allow fanning out\nshare/copy operations on larger number of backups.\n\nIf you want ot enforce linear execution (only possible when running as CLI), set environment variable `SHELVERY_MONO_THREAD=1`.\nThis will ensure all shares / copies are done in single thread, and can prolong backup creation execution, as backup must be\nin *available* state prior it can be shared or copied.\n\n## AWS Credentials configuration\n\nShelvery uses boto3 as client library to communicate with Amazon Web Services. Use any environment variables that\nboto3 supports to configure credentials. In Amazon Lambda environment, shelvery will pick up IAM credentials from\nIAM role that Lambda is running under.\n\n## Runtime environment\n\nShelvery requires Python3.11 to run. You can run it either from any server or local machine capable of interpreting\nPython3.11 code, or as Amazon Lambda functions. All Shelvery code is written in such way that it supports\nboth CLI and Lambda execution.\n\n## Backup lifecycle and retention periods\n\nAny backups created via shelvery will get tagged with metadata, including backup name, creation time, and backup retention type (daily, weekly, monthly or yearly). Retention is following Grandfather-father-son [backup scheme](https://en.wikipedia.org/wiki/Backup_rotation_scheme).\nStale backups are cleaned using cleanup commands, according to retention policy.\nDefault retention policy is as follows\n\n- Keep daily backups for 14 days\n- Keep weekly backups for 8 weeks\n- Keep monthly backups for 12 months\n- Keep yearly backups for 10 years\n\nOnly one type of backup is created per shelvery run, and determined by current date. Rules are following\n\n1. If running shelvery on 1st January, yearly backups will be created\n2. If running shelvery on 1st of the month, monthly backup will be created\n3. If running shelvery on Sunday, weekly backup will be created\n4. Any other day, daily backup is being created\n\nAll retention policies can be tweaked using runtime configuration, explained in the **Runtime Configuration** section\nRetention period is calculated at cleanup time, meaning lifetime of the backup created is not fixed, e.g. determined\nat backup creation, but rather dynamic. This allows greater flexibility for the end user - e.g. extending daily backup\npolicy from last 7 to last 14 days will preserve all backups created in past 7 days, for another 7 days.\n\n## What resources are being backed up\n\nFor following resource types:\n\n- EC2 Volumes\n- EC2 Instances\n- RDS Instances\n- RDS Clusters\n- Redshift Clusters\n- DocumentDb\n\nSimply  add `shelvery:create_backup` tag with any of the following values\n\n- `True`\n- `true`\n- `1`\n\nto resource that should be backed up.\n\nResources that are not marked to be manage by shelvery are skipped.\nOptionally you can export `shelvery_select_entity` environment variable to select single resource, though\ntagging condition still applies.\n\n## Notifications\n\nAll shelvery operations are being pushed to SNS topics, if configured (see `shelvery_sns_topic` and `shelvery_error_sns_topic` key in\nRuntimeConfiguration section below), whether success or failure. From SNS topic you send emails,\nsubscribe custom Lambda functions, send payload to HTTP(S) endpoints etc. This allows monitoring systems\nto hook into shelvery, and possibly alert on any errors occurred.\n\n## Supported services\n\n### EC2\n\nEBS Backups in form of EBS Snapshots is supported. EC2 Instance backups in form of Amazon Machine Images (AMIs) is supported as well.\n\n### RDS\n\nRDS Backups are supported in form of RDS Snapshots. There is no support for sql dumps at this point. By default, RDS\nsnapshots are created as copy of the last automated snapshot. Set configuration key `shelvery_rds_backup_mode` to `RDS_CREATE_SNAPSHOT`\nif you wish to directly create snapshot. Note that this may fail if RDS instance is not in `available` state\n\n### RDS Clusters\n\nRDS Cluster backups behave same as RDS instance backups, just on RDS Clusters (Aurora). Value of `shelvery_rds_backup_mode` has the same effect as for RDS instance backups.\n\n### Redshift clusters\n\nRedshift cluster snapshots are supported to an extent. Creating and cleaning backups is fully supported,\nwhereas copying snapshot to DR region (or pulling shared snapshot from DR account) is not\nsupported natively through API, but can be achieved using data transfer through S3 buckets,\n`UNLOAD/COPY` statements, and `EnableSnapshotCopy` API call. This operations however are currenlty outside\nof Shelvery scope\n\n### DocumentDb\n\nDocumentDb backups behave same as RDS instance backups, just on DocumentDb Clusters. Value of `shelvery_docdb_backup_mode` has the same effect as `shelvery_rds_backup_mode` for RDS instance and cluster backups.\n\n## Runtime Configuration\n\nThere are multiple configuration options for the shelvery backup engine, configurable on multiple levels.\nLevels with higher priority number take precedence over the ones with lower priority number. Lowest priority\nare defaults that are set in code. Look at `shelvery/runtime_config.py` source code file for more information.\n\n### Keys\n\nAvailable configuration keys are listed below:\n\n- `shelvery_keep_daily_backups` - Number of days to retain daily backups\n- `shelvery_keep_weekly_backups` - Number of weeks to retain weekly backups\n- `shelvery_keep_monthly_backups` - Number of months to keep monthly backups\n- `shelvery_keep_yearly_backups` - Number of years to keep yearly backups\n\n- `shelvery_custom_retention_types` - custom retention periods in name:seconds (quarterHourly:86400) format, comma separated, empty (disabled) by default\n- `shelvery_current_retention_type` - custom retention period applied to current create backup process\n\n- `shelvery_dr_regions` - List of disaster recovery regions, comma separated\n- `shelvery_wait_snapshot_timeout` - Timeout in seconds to wait for snapshot to become available before copying it\nto another region or sharing with other account. Defaults to 1200 (20 minutes)\n- `shelvery_share_aws_account_ids` -  AWS Account Ids to share backups with. Applies to both original and regional backups\n- `shelvery_source_aws_account_ids` - List of AWS Account Ids, comma seperated, that are exposing/sharing their shelvery\n    backups with account where shelvery is running. This can be used for having DR aws account that aggregates backups\n    from other accounts.\n- `shelvery_bucket_name_template` - Template used to create bucket name. Available keys: `{account_id}`, `{region}`. Defaults to `shelvery.data.{account_id}-{region}.base2tools`\n- `shelvery_rds_backup_mode` - can be either `RDS_COPY_AUTOMATED_SNAPSHOT` or `RDS_CREATE_SNAPSHOT`. Values are self-explanatory\n- `shelvery_docdb_backup_mode` - can be either `DOCDB_COPY_AUTOMATED_SNAPSHOT` or `DOCDB_CREATE_SNAPSHOT`. Values are self-explanatory\n- `shelvery_redshift_backup_mode` - can be either `REDSHIFT_COPY_AUTOMATED_SNAPSHOT` or `REDSHIFT_CREATE_SNAPSHOT`. Values are self-explanatory\n- `shelvery_lambda_max_wait_iterations` - maximum number of chained calls to wait for backup availability\nwhen running Lambda environment. `shelvery_wait_snapshot_timeout` will be used only in CLI mode, while this key is used only\non Lambda\n\n- `shelvery_select_entity` - select only single resource to be backed up, rather than all tagged with shelvery tags.\nThis resource still needs to have shelvery tag on it to be backed up.\n\n- `shelvery_sns_topic` - SNS Topic to publish event messages, including error messages for failed\nbackups\n- `shelvery_error_sns_topic` - SNS Topic for receiving just errors. If not set all messages will be sent through `shelvery_sns_topic` topic\n- `shelvery_source_aws_account_ids` - Comma-separated list of AWS account ids to pull backups from\n\n- `shelvery_copy_resource_tags` - Copy tags from original resource [boolean]\n- `shelvery_exluded_resource_tag_keys` - Comma separated list of tag keys to exclude from copying from original\n\n- `shelvery_sqs_queue_url` - SQS queue url\n- `shelvery_sqs_queue_wait_period` - sqs waiting period in seconds. [int] 0-900\n\n- `shelvery_ignore_invalid_resource_state` - ignore exceptions due to the resource being in a unavailable state, such as shutdown, rebooting. Default value is `False`. [boolean]\n\n- `shelvery_encrypt_copy` - [boolean] when copying a shared unencrypted snapshot, encrypt the shapshot. \n                            when enabled 'shelvery_copy_kms_key_id' must also be set.\n\n- `shelvery_copy_kms_key_id` - when copying a shared snapshot, you can specify a different kms key used to encrypt the original snapshot.\n                               Note that when copying to a new key, the shelvery requires access to both the new key and the original key.\n                               The full KMS key ARN should be supplied.\n\n- `shelvery_reencrypt_kms_key_id`  - when it is required to re-encrypt a RDS instance or cluster snapshot with a different KMS key \n                                than that of the existing resource. Specify the ARN of the KMS Key.\n\n### Configuration Priority 0: Sensible defaults\n\n```text\nshelvery_keep_daily_backups=14\nshelvery_keep_weekly_backups=8\nshelvery_keep_monthly_backups=12\nshelvery_keep_yearly_backups=10\nshelvery_wait_snapshot_timeout=120\nshelvery_lambda_max_wait_iterations=5\n```\n\n### Configuration Priority 1: Environment variables\n\n```shell\n$ export shelvery_rds_backup_mode=RDS_CREATE_SNAPSHOT\n$ shelvery rds create_backups\n```\n\n### Configuration Priority 2: Lambda Function payload\n\nAny keys passed to the lambda function event payload (if shelvery is running in Lambda environment), under `config` key will hold priority over environment variables. E.g. following payload will clean ebs backups, with rule to delete dailies older\nthan 5 days\n\n```json\n{\n  \"backup_type\": \"ebs\",\n  \"action\": \"clean_backups\",\n  \"config\": {\n    \"shelvery_keep_daily_backups\": 5\n  }\n}\n```\n\n### Configuration Priority 3: Resource tags\n\nResource tags apply for retention period and DR regions. E.g. putting following tag on your EBS volume,\nwill ensure it's daily backups are retained for 30 days, and copied to `us-west-1` and `us-west-2`.\n`shelvery_share_aws_account_ids` is not available on a resource level (Pull Requests welcome)\n\n`shelvery:config:shelvery_keep_daily_backups=30`\n\n`shelvery:config:shelvery_dr_regions=us-west-1,us-west-2`\n\nGeneric format for shelvery config tag is `shevlery:config:$configkey=$configvalue`\n\n### Custom retention periods\n\nCustom retention periods can be set using `shelvery_custom_retention_types` formatted as `[name:retention period]` where retention period defined in seconds.\nMultiple periods can be set using a comma separated list.\n\n```text\nshelvery_custom_retention_types=quarterHourly:86400,hourly:172800\n```\n\nWhen triggering shelvery on the desired schedule, specify the retention type using `shelvery_current_retention_type` tag with the desired retention type\n\n```text\nshelvery_current_retention_type=quarterHourly\n```\n\n## Multi account setup\n\nShelvery allows setting up disaster recovery AWS account with\nall of the backups from organisations AWS accounts copied to\n'disaster recovery' account.\n\n1) Sharing backups with other accounts\n\n```bash\n# this runs in every\n# running in account 222222222222,333333333333\n$ export AWS_DEFAULT_PROFILE=source_account\n$ export shelvery_share_aws_account_ids=111111111111\n$ shelvery ebs create_backups\n```\n\n2) Copying shared backups from other acccount into current account\n\n```bash\n# this is running in destination account, let's say 111111111111\n$ export AWS_DEFAULT_PROFILE=dst_account\n$ export shelvery_source_aws_account_ids=222222222222,333333333333\n# this command will pull backups from both accounts\n$ shelvery ebs pull_shared_backups\n```\n\n## Cross-account copying of encrypted backups\n\nShelvery enables the sharing and copying of encrypted backups between accounts. In order to configure this, you must share the backup's KMS key and follow the instructions in step #2 above. A new kms key can be used when copying the shared snapshot or you can encrypt an unencrypted snapshot when coying to the shared account.\n\nFor instructions on how to share the KMS key, see https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ShareSnapshot.html\n\nThis is currently only supported for:\n  - RDS clusters\n  - RDS Instances\n\n## Waiting on backups to complete\n\nBy default shelvery will wait by sleeping and then querying the aws api for a complete status.\nIf this is not your preferred method you can offload the sleep to SQS to save costs on lambda compute.\n\nYou can set the sqs url and the wait period (seconds) before lambda is invoked to check on the status of the backup.\nIf the backup is not complete it will be passed back to sqs to wait for the same period.\n\n```text\nshelvery_sqs_queue_url=https://sqs.us-east-1.amazonaws.com/111111111111/shelvery\nshelvery_sqs_queue_wait_period=300\n```\n\n## Deploying with SAM template\n\n1. Install the [AWS SAM cli](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)\n\n2. Setup you aws credentials and set the region\n\n    ```bash\n    export AWS_PROFILE=profile\n    export AWS_DEFAULT_REGION=ap-southeast-2\n    ```\n    \n    or using sts keys\n    \n    ```bash\n    export AWS_ACCESS_KEY_ID=xxx\n    export AWS_SECRET_ACCESS_KEY=xxx\n    export AWS_SESSION_TOKEN=xxx\n    ```\n\n3. Run the `deploy-sam-template.sh` script with the options to deploy the template in the target account.\n\n    ```bash\n    $ ./deploy-sam-template.sh help\n    \n    Usage:\n      ./deploy-sam-template.sh -b my-s3-bucket -r us-west-2     # deploy latest shelvery version in the us-west-2 region\n      ./deploy-sam-template.sh -b my-s3-bucket -l true -p true  # package and deploy the current git branch\n\n    Options:\n      -b BUCKET                     # s3 bucket to deploy the sam package to\n      [-v VERSION]                  # set the shelvery version to deploy, defaults to x.x.x\n      [-r REGION]                   # AWS region to deploy shelvery, if not set it will get from the aws config or environment\n      [-p true] BOOLEAN             # Build and package shelvery from the current branch. Use with '-l true' to deploy the package.\n      [-l true] BOOLEAN             # install shelvery from a local dist build in the ./dist/shelvery-${SHELVERY_VERSION}.tar.gz\n      [-o KEY1=VALUE1,KEY2=VALUE2]  # Override cloudformation template parameters with a comma separated string of key value pairs\n                                    # e.g. -o ShelveryRdsBackupMode=RDS_CREATE_SNAPSHOT,ShelveryEncryptCopy=true\n      [-u UID]                      # Set the docker user id, defaults to -u 501\n    ```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fbase2services%2Fshelvery-aws-backups","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fbase2services%2Fshelvery-aws-backups","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fbase2services%2Fshelvery-aws-backups/lists"}