def get_backup_resource(self, region: str,
backup_id: str) -> BackupResource:
ec2 = boto3.session.Session(region_name=region).resource('ec2')
snapshot = ec2.Snapshot(backup_id)
d_tags = dict(map(lambda t: (t['Key'], t['Value']), snapshot.tags))
return BackupResource.construct(d_tags['shelvery:tag_name'], backup_id,
d_tags)
def get_shelvery_backups_only(self, all_snapshots, backup_tag_prefix,
rds_client):
"""
:param all_snapshots: all snapshots within region
:param backup_tag_prefix: prefix of shelvery backup system
:param rds_client: amazon boto3 rds client
:return: snapshots created using shelvery
"""
all_backups = []
marker_tag = f"{backup_tag_prefix}:{BackupResource.BACKUP_MARKER_TAG}"
for snap in all_snapshots:
tags = snap['TagList']
self.logger.info(
f"Checking RDS Snap {snap['DBClusterSnapshotIdentifier']}")
d_tags = dict(map(lambda t: (t['Key'], t['Value']), tags))
if marker_tag in d_tags:
if d_tags[marker_tag] in SHELVERY_DO_BACKUP_TAGS:
backup_resource = BackupResource.construct(
backup_tag_prefix, snap['DBClusterSnapshotIdentifier'],
d_tags)
backup_resource.entity_resource = snap['EntityResource']
backup_resource.entity_id = snap[
'EntityResource'].resource_id
all_backups.append(backup_resource)
return all_backups
def get_existing_backups(self, tag_prefix: str) -> List[BackupResource]:
ec2client = AwsHelper.boto3_client('ec2',
arn=self.role_arn,
external_id=self.role_external_id)
# lookup snapshots by tags
snapshots = ec2client.describe_snapshots(Filters=[{
'Name': f"tag:{tag_prefix}:{BackupResource.BACKUP_MARKER_TAG}",
'Values': ['true']
}])
backups = []
# create backup resource objects
for snap in snapshots['Snapshots']:
snap_tags = dict(
map(lambda t: (t['Key'], t['Value']), snap['Tags']))
if f"{tag_prefix}:ami_id" in snap_tags:
self.logger.info(
f"EBS snapshot {snap['SnapshotId']} created by AMI shelvery backup, skiping..."
)
continue
backup = BackupResource.construct(tag_prefix=tag_prefix,
backup_id=snap['SnapshotId'],
tags=snap_tags)
# legacy code - entity id should be picked up from tags
if backup.entity_id is None:
self.logger.info(
f"SnapshotId is None, using VolumeId {snap['VolumeId']}")
backup.entity_id = snap['VolumeId']
backups.append(backup)
self.populate_volume_information(backups)
return backups
def get_backup_resource(self, backup_region: str, backup_id: str) -> BackupResource:
rds_client = boto3.client('rds', region_name=backup_region)
snapshots = rds_client.describe_db_cluster_snapshots(DBClusterSnapshotIdentifier=backup_id)
snapshot = snapshots['DBClusterSnapshots'][0]
tags = rds_client.list_tags_for_resource(ResourceName=snapshot['DBClusterSnapshotArn'])['TagList']
d_tags = dict(map(lambda t: (t['Key'], t['Value']), tags))
return BackupResource.construct(d_tags['shelvery:tag_name'], backup_id, d_tags)
def get_existing_backups(self,
backup_tag_prefix: str) -> List[BackupResource]:
"""
Collect existing backups on system of given type, marked with given tag
"""
local_region = boto3.session.Session().region_name
marker_tag = f"{backup_tag_prefix}:{BackupResource.BACKUP_MARKER_TAG}"
response = self.redshift_client.describe_cluster_snapshots(
SnapshotType='manual',
TagKeys=[marker_tag],
TagValues=SHELVERY_DO_BACKUP_TAGS)
snapshots = response['Snapshots']
backups = []
for snap in snapshots:
cluster_id = snap['ClusterIdentifier']
d_tags = BackupResource.dict_from_boto3_tags(snap['Tags'])
create_time = snap['ClusterCreateTime']
redshift_entity = EntityResource(cluster_id, local_region,
create_time, d_tags)
backup_id = f"arn:aws:redshift:{local_region}:{snap['OwnerAccount']}"
backup_id = f"{backup_id}:snapshot:{snap['ClusterIdentifier']}/{snap['SnapshotIdentifier']}"
backup_resource = BackupResource.construct(backup_tag_prefix,
backup_id, d_tags)
backup_resource.entity_resource = redshift_entity
backup_resource.entity_id = redshift_entity.resource_id
backups.append(backup_resource)
return backups
def get_backup_resource(self, region: str,
backup_id: str) -> BackupResource:
ami = self.ec2client.describe_images(ImageIds=[backup_id])['Images'][0]
d_tags = dict(map(lambda x: (x['Key'], x['Value']), ami['Tags']))
backup_tag_prefix = d_tags['shelvery:tag_name']
backup = BackupResource.construct(backup_tag_prefix, backup_id, d_tags)
return backup
def get_backup_resource(self, region: str, backup_id: str) -> BackupResource:
ec2client = AwsHelper.boto3_client('ec2', arn=self.role_arn, external_id=self.role_external_id)
ami = ec2client.describe_images(ImageIds=[backup_id])['Images'][0]
d_tags = dict(map(lambda x: (x['Key'], x['Value']), ami['Tags']))
backup_tag_prefix = d_tags['shelvery:tag_name']
backup = BackupResource.construct(backup_tag_prefix, backup_id, d_tags)
return backup
def get_backup_resource(self, backup_region: str, backup_id: str) -> BackupResource:
docdb_client = AwsHelper.boto3_client('docdb', region_name=backup_region, arn=self.role_arn, external_id=self.role_external_id)
snapshots = docdb_client.describe_db_cluster_snapshots(DBClusterSnapshotIdentifier=backup_id)
snapshot = snapshots['DBClusterSnapshots'][0]
tags = docdb_client.list_tags_for_resource(ResourceName=snapshot['DBClusterSnapshotArn'])['TagList']
d_tags = dict(map(lambda t: (t['Key'], t['Value']), tags))
resource = BackupResource.construct(d_tags['shelvery:tag_name'], backup_id, d_tags)
resource.resource_properties = snapshot
return resource
def get_backup_resource(self, region: str,
backup_id: str) -> BackupResource:
ec2 = AwsHelper.boto3_session('ec2',
region_name=region,
arn=self.role_arn,
external_id=self.role_external_id)
snapshot = ec2.Snapshot(backup_id)
d_tags = dict(map(lambda t: (t['Key'], t['Value']), snapshot.tags))
return BackupResource.construct(d_tags['shelvery:tag_name'], backup_id,
d_tags)
def get_backup_resource(self, backup_region: str,
backup_id: str) -> BackupResource:
"""
Get Backup Resource within region, identified by its backup_id
"""
redshift_client = AwsHelper.boto3_client(
'redshift',
region_name=backup_region,
arn=self.role_arn,
external_id=self.role_external_id)
snapshot_id = backup_id.split(":")[-1].split("/")[1]
snapshots = redshift_client.describe_cluster_snapshots(
SnapshotIdentifier=snapshot_id)
snapshot = snapshots['Snapshots'][0]
d_tags = BackupResource.dict_from_boto3_tags(snapshot['Tags'])
return BackupResource.construct(d_tags['shelvery:tag_name'], backup_id,
d_tags)
def get_existing_backups(self, tag_prefix: str) -> List[BackupResource]:
# lookup snapshots by tags
snapshots = self.ec2client.describe_snapshots(
Filters=[{
'Name': f"tag:{tag_prefix}:{BackupResource.BACKUP_MARKER_TAG}",
'Values': ['true']
}])
backups = []
# create backup resource objects
for snap in snapshots['Snapshots']:
backup = BackupResource.construct(
tag_prefix=tag_prefix,
backup_id=snap['SnapshotId'],
tags=dict(map(lambda t: (t['Key'], t['Value']), snap['Tags'])))
backup.entity_id = snap['VolumeId']
backups.append(backup)
self.populate_volume_information(backups)
return backups
def get_existing_backups(self,
backup_tag_prefix: str) -> List[BackupResource]:
amis = self.ec2client.describe_images(Filters=[{
'Name':
f"tag:{backup_tag_prefix}:{BackupResource.BACKUP_MARKER_TAG}",
'Values': ['true']
}])['Images']
backups = []
instances = dict(
map(lambda x: (x.resource_id, x), self._get_all_entities()))
for ami in amis:
backup = BackupResource.construct(
backup_tag_prefix, ami['ImageId'],
dict(map(lambda x: (x['Key'], x['Value']), ami['Tags'])))
if backup.entity_id in instances:
backup.entity_resource = instances[backup.entity_id]
backups.append(backup)
return backups