Czy można skopiować grupę bezpieczeństwa AWS?

Mamy kilka grup zabezpieczeń, które mają w sobie sporo reguł. Czy zamiast kopiować te same reguły dla kilku grup zabezpieczeń, aby uwzględnić niewielkie różnice, czy można skopiować grupę zabezpieczeń i użyć jej jako punktu początkowego, czy użyć dziedziczenia itp.?

Nie wygląda na to, że można skopiować grupy zabezpieczeń z interfejsu internetowego. Możesz jednak użyć interfejsu AWS CLI, aby utworzyć grupy zabezpieczeń :

Komenda :

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

Wynik :

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

I dodaj reguły za pomocą polecenia:

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

Wynik:

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

Stamtąd powinieneś być w stanie dowiedzieć się, jak uprościć tworzenie grup zabezpieczeń.

AWS EC2 Console pozwala wybrać grupę zabezpieczeń i wykonać teraz operację „Kopiuj do nowego” w interfejsie użytkownika.

Z AWS Tworzenie dokumentów grupy zabezpieczeń , możesz skopiować grupę zabezpieczeń za pomocą konsoli.

1. Wybierz grupę zabezpieczeń, którą chcesz skopiować
2. Wybrać działanie
3. Skopiuj do nowego

Rozważ obejrzenie tego bloga. Może to być przydatne do tego, na co patrzysz.

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

Oto metoda python / boto „kopiuj grupy zabezpieczeń” z niestandardowej biblioteki, którą napisałem, aby ułatwić te rzeczy / zautomatyzować je. Ostatecznie takie rozwiązanie wymyśliłem.

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

Reszta powinna być prosta do zrozumienia.

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 

Oto skrypt, który stworzyłem, aby to osiągnąć: aws_sg_migrate

Przykładowe użycie to

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

Jest oparty na tym i dostosowany do Python3.

W tym samym regionie AWS możesz skopiować zasady bezpieczeństwa za pomocą graficznego interfejsu użytkownika. Czasami jednak chcesz skopiować programowo. Na przykład, jeśli masz wiele zasad bezpieczeństwa do skopiowania lub chcesz kopiować między regionami.

Oto prosty fragment, aby to zrobić.

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'])

Z powodu braku odpowiedniego sposobu na zrobienie tego online stworzyłem bardzo prosty skrypt do obsługi tego. Zajrzyj, jeśli jesteś zainteresowany.

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

W konsoli EC2 kliknij opcję Uruchom wystąpienie i kontynuuj wprowadzanie informacji zastępczych, dopóki nie przejdziesz do sekcji grupy zabezpieczeń.

Stąd kliknij „Wybierz istniejącą grupę zabezpieczeń”, a poniżej zobaczysz wszystkie grupy zabezpieczeń, które masz dla tego konkretnego VPC. Powinieneś zobaczyć link „Kopiuj do nowego” w sekcji „Akcje”, użyj go, aby skopiować wszystkie listy ACL do nowej SG.

Albo przypuszczam, że możesz użyć skryptu - jest to szybsze IMO ..

Miałem podobny problem, ale kopiowałem SG na różne konta.

Po prostu określ KONSTANTY na początku, a funkcja copy_sg je skopiuje.

Nie ma kontroli błędów, więc jeśli docelowy SG już istnieje, zawiedzie.

Postępuj zgodnie z ogólnym rozwiązaniem, które można zastosować również na koncie:

#!/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)