È possibile copiare un gruppo di sicurezza AWS?

Abbiamo alcuni gruppi di sicurezza che hanno alcune regole. Invece di dover ricreare le stesse regole per un certo numero di gruppi di sicurezza solo per far fronte a differenze minori, è possibile copiare un gruppo di sicurezza da utilizzare come punto di partenza o utilizzare l'ereditarietà, ecc.?

Non sembra che tu possa copiare gruppi di sicurezza dall'interfaccia web. Puoi tuttavia utilizzare l' interfaccia della riga di comando di AWS per creare gruppi di sicurezza :

Comando:

$ aws ec2 describe-security-groups --group-id MySecurityGroupID

Produzione :

{
    "securityGroupInfo": [
        {
            "ipPermissionsEgress": [],
            "groupId": "sg-903004f8",
            "ipPermissions": [],
            "groupName": "MySecurityGroup",
            "ownerId": "803981987763",
            "groupDescription": "AWS-CLI-Example"
        }
    ],
    "requestId": "afb680df-d7b1-4f6a-b1a7-344fdb1e3532"
}

E aggiungi le regole usando il comando:

aws ec2 authorize-security-group-ingress --group-id MySecurityGroupID --ip-protocol tcp --from-port 22 --to-port 22 --cidr-ip 0.0.0.0/0

Produzione:

{
    "return": "true",
    "requestId": "c24a1c93-150b-4a0a-b56b-b149c0e660d2"
}

Da lì dovresti essere in grado di capire come semplificare la creazione dei tuoi gruppi di sicurezza.

AWS EC2 Console ti consente di selezionare il gruppo di sicurezza ed eseguire ora l'operazione "Copia in nuovo" nell'interfaccia utente.

Da AWS Creazione di documenti di un gruppo di sicurezza , puoi copiare un gruppo di sicurezza utilizzando la console.

1. Seleziona il gruppo di sicurezza che desideri copiare
2. Scegli un'azione
3. Copia in nuovo

Valuta di dare un'occhiata a questo blog. Potrebbe essere utile per quello che stai guardando.

http://ry4an.org/unblog/post/ec2_security_group_tools/

Ecco il metodo python / boto di "copia gruppi di sicurezza" da una libreria personalizzata che ho scritto per rendere più facile / automatizzare questo tipo di cose. In definitiva, questa è stata la soluzione che mi è venuta in mente.

vpcId is the Virtual Private Cloud Id
keys is a dictionary with your AWS keys

Il resto dovrebbe essere semplice da capire.

def copyEC2SecurityGroup(self, keys, region, securityGroupName, newSecurityGroupName = None, newRegion = None, vpcId = None):


newEc2Connection = None
print("Creating ec2Connection for source region: " + region)
ec2Connection = lib.getEc2Connection(region, keys)

if newRegion is None:
    newRegion = region
else:
    print("New Region Detected, creating for New region: " + newRegion)
    newEc2Connection = lib.getEc2Connection(newRegion, keys)
    newRegionInfo = newEc2Connection.region

print("new region is: %s" % newRegion)

if newSecurityGroupName is None:
    newSecurityGroupName = securityGroupName

print ("new security group is: %s" % newSecurityGroupName)

# if copying in the same region the new security group cannot have the same name.
if newRegion == region:
    if newSecurityGroupName == securityGroupName:
        print ("Old and new security groups cannot have the same name when copying to the same region.")
        exit(1)

groups = [group for group in ec2Connection.get_all_security_groups() if group.name == securityGroupName]
print"got groups count " + str(len(groups))
if groups:
    theOldGroup = groups[0]
    print theOldGroup.rules
else:
    print("Can't find security group by the name of: %s" % securityGroupName)
    exit(1)
print groups
pprint(theOldGroup)

if newEc2Connection is not None:
    print("Creating new security group in new region")
    sg = newEc2Connection.create_security_group(newSecurityGroupName, newSecurityGroupName, vpcId)
    sleep(5)
else:
    print("Creating new security group in current region")
    sg = ec2Connection.create_security_group(newSecurityGroupName, newSecurityGroupName, vpcId)
    sleep(5)

source_groups = []
for rule in theOldGroup.rules:
    for grant in rule.grants:
        strGrant = str(grant)
        print(strGrant)
        if strGrant.startswith("sg"):
            print("Cannot copy 'security group rule' (%s)... only cidr_ip's e.g. xxx.xxx.xxx.xxx/yy." % strGrant)
            continue
        grant_nom = grant.name or grant.group_id
        if grant_nom:
            if grant_nom not in source_groups:
                source_groups.append(grant_nom)
                sg.authorize(rule.ip_protocol, rule.from_port, rule.to_port, grant)
        else:
            sg.authorize(rule.ip_protocol, rule.from_port, rule.to_port, grant.cidr_ip)
return sg 

Ecco lo script che ho realizzato per ottenere questo risultato: aws_sg_migrate

L'uso del campione è

python3 aws_sg_migrate.py --vpc=vpc-05643b6c --shell --src=us-east-1 --dest=us-west-1 sg-111111

Si basa su questo e adattato per Python3.

All'interno della stessa area AWS, puoi copiare una politica di sicurezza utilizzando la GUI online. Tuttavia, a volte vuoi copiare le cose a livello di codice. Ad esempio, se hai molti criteri di sicurezza da copiare o se vuoi copiarli in più aree.

Ecco un semplice frammento per farlo.

import boto3
from os import environ as env


def copy_security_groups(src_region, tgt_region, grp_names):

    # Initialize client connections for regions
    src_client = boto3.client('ec2', region_name=src_region,
                              aws_access_key_id=env['AWS_ACCESS_KEY_ID'],
                              aws_secret_access_key=env['AWS_SECRET_ACCESS_KEY'])
    tgt_client = boto3.client('ec2', region_name=tgt_region,
                              aws_access_key_id=env['AWS_ACCESS_KEY_ID'],
                              aws_secret_access_key=env['AWS_SECRET_ACCESS_KEY'])

    # Get info for all security groups and copy them one-by-one
    g_info = src_client.describe_security_groups(
        GroupNames=grp_names)['SecurityGroups']
    for g in g_info:
        resp = tgt_client.create_security_group(
            GroupName=g['GroupName'], Description=g['Description'])
        new_grp_id = resp['GroupId']
        tgt_client.authorize_security_group_ingress(
            GroupId=new_grp_id, IpPermissions=g['IpPermissions'])
        tgt_client.authorize_security_group_egress(
            GroupId=new_grp_id, IpPermissions=g['IpPermissionsEgress'])


if __name__ == '__main__':
    copy_security_groups('us-east-1', 'ap-south-1', ['rds-public'])

A causa della mancanza di un modo corretto di farlo online, ho creato uno script super semplice per gestirlo. Dai un'occhiata se sei interessato.

https://github.com/pedropregueiro/migrate-ec2-secgroups

Dalla console EC2, fare clic su Avvia istanza e procedere all'inserimento delle informazioni fittizie fino ad arrivare alla sezione del gruppo di sicurezza.

Da qui fai clic su "Seleziona un gruppo di sicurezza esistente" e sotto vedrai tutti i gruppi di sicurezza che hai per quel particolare VPC. Dovresti vedere un link "Copia in nuovo" in "Azioni", utilizzalo per copiare tutti i tuoi ACL in un nuovo SG.

O suppongo che potresti usare uno script - questo è più veloce IMO ..

Ho avuto un problema simile ma ho copiato SG su diversi account.

Basta specificare alcuni COSTANTI all'inizio e la funzione copy_sg li copierà.

Non è presente alcun controllo degli errori, pertanto se l'SG di destinazione esiste già non funzionerà.

Segui una soluzione generale che può essere utilizzata anche all'interno dell'account:

#!/usr/bin/env python3
# coding: utf-8

import boto3
from typing import Any,  List

# This profile needs to be able to assume the specified role in SRC/TGT account
appops_session = boto3.Session(profile_name='YOUR_PRECONFIGURE_PROFILE')

ROLE = "THE ROLE TO BE ASSUMED"  # I presume it is the same in SRC/TGT Account
SRC_ACCOUNT = "YOUR SRC ACCOUNT NUMBER"

TGT_REGION = "eu-central-1"
DST_ACCOUNT = "YOUR TARGET ACCOUNT NUMBER"
TGT_VPC = "vpc-XXXXXXXXXXXXXXX"

region = "ap-southeast-2"
dst_vpc_id = "vpc-XXXXXXXXXXXXXXX"
sg_list = ["sg-XXXXXXXX", "sg-YYYYYYYYY"]

def aws_sts_cred(account, role):
    """Get the STS credential.

    return  credential_object
    """
    sts_creds = {}
    sts_conn = appops_session.client('sts')

    role_arn = "arn:aws:iam::" + account + ":role/" + role
    assumed_role = sts_conn.assume_role(RoleArn=role_arn,
                                        RoleSessionName="TMPROLE")
    sts_creds["aws_access_key_id"] = assumed_role['Credentials']['AccessKeyId']
    sts_creds["aws_secret_access_key"] = assumed_role['Credentials']['SecretAccessKey']
    sts_creds["aws_session_token"] = assumed_role['Credentials']['SessionToken']
    return sts_creds


def aws_conn(service: str, region: str, **kwargs) -> Any:
    """Create a client object."""
    return boto3.client(service, region_name=region, **kwargs)


def dump_sg(client, vpcid: str = "", sgids: List = []) -> List:
    """Dump the specified SG."""
    print(sgids)
    sg_info = client.describe_security_groups(
            Filters = [{'Name': 'group-id', 'Values': sgids}])['SecurityGroups']
    return sg_info


def copy_sg(tgt_client, sgs, vpcid=""):
    for sg in sgs:
        # With no Vpc ID the SG is created in the default VPC.
        resp = tgt_client.create_security_group(
            GroupName=sg['GroupName'], Description=sg['Description'], VpcId=vpcid)
        new_grp_id = resp['GroupId']
        tgt_client.authorize_security_group_ingress(
            GroupId=new_grp_id, IpPermissions=sg.get('IpPermissions', list()))
        if sg.get('IpPermissionsEgress') != []:
            # It doesn't work with an empty list
            tgt_client.authorize_security_group_egress(
                GroupId=new_grp_id, IpPermissions=sg.get('IpPermissionsEgress'))
        print("Create SG {} - \"{}\" - \"{}\" in VPCID: {}".format(new_grp_id, sg['GroupName'], sg['Description'], vpcid))


STS_CRED = aws_sts_cred(SRC_ACCOUNT, ROLE)
STS_CRED_TGT = aws_sts_cred(DST_ACCOUNT, ROLE)

src_client = aws_conn("ec2", region, **STS_CRED)

sg_list = dump_sg(src_client, sgids=sg_list)

tgt_client = aws_conn("ec2", TGT_REGION, **STS_CRED_TGT)

copy_sg(tgt_client, sg_list)