Ist es möglich, eine AWS-Sicherheitsgruppe zu kopieren?

Wir haben einige Sicherheitsgruppen, die einige Regeln enthalten. Ist es möglich, eine Sicherheitsgruppe zu kopieren, um sie als Ausgangspunkt zu verwenden, oder Vererbung usw. zu verwenden, anstatt dieselben Regeln für eine Reihe von Sicherheitsgruppen erneut erstellen zu müssen, um kleinere Unterschiede auszugleichen?

Sieht nicht so aus, als könnten Sie Sicherheitsgruppen von der Weboberfläche kopieren. Sie können jedoch die AWS-CLI verwenden , um Sicherheitsgruppen zu erstellen :

Befehl :

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

Ausgabe :

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

Und fügen Sie Regeln mit dem Befehl hinzu:

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

Ausgabe:

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

Von dort aus sollten Sie herausfinden können, wie Sie die Erstellung Ihrer Sicherheitsgruppen vereinfachen können.

Mit AWS EC2 Console können Sie jetzt die Sicherheitsgruppe auswählen und den Vorgang "In neue kopieren" auf der Benutzeroberfläche ausführen.

In AWS- Dokumenten zum Erstellen einer Sicherheitsgruppe können Sie eine Sicherheitsgruppe über die Konsole kopieren.

1. Wählen Sie die Sicherheitsgruppe aus, die Sie kopieren möchten
2. Aktion wählen
3. In neues kopieren

Hier ist die Python / Boto-Methode zum Kopieren von Sicherheitsgruppen aus einer benutzerdefinierten Bibliothek, die ich geschrieben habe, um diese Dinge zu vereinfachen / zu automatisieren. Letztendlich war dies die Lösung, die ich mir ausgedacht habe.

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

Der Rest sollte einfach herauszufinden sein.

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 

Schauen Sie sich doch mal diesen Blog an. Es könnte nützlich für das sein, was Sie sich ansehen.

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

Hier ist das Skript, das ich dazu erstellt habe: aws_sg_migrate

Beispielnutzung ist

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

Es basiert auf diesem und ist für Python3 angepasst.

Innerhalb derselben AWS-Region können Sie eine Sicherheitsrichtlinie über die Online-GUI kopieren. Manchmal möchten Sie jedoch programmgesteuert kopieren. Zum Beispiel, wenn Sie viele Sicherheitsrichtlinien kopieren müssen oder wenn Sie über Regionen hinweg kopieren möchten.

Hier ist ein einfacher Ausschnitt, um das zu tun.

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

Da dies online nicht ordnungsgemäß funktioniert, habe ich ein supereinfaches Skript erstellt, um damit umzugehen. Schauen Sie doch mal rein, wenn Sie interessiert sind.

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

Klicken Sie in der EC2-Konsole auf Instanz starten und geben Sie die Dummy-Informationen ein, bis Sie zum Abschnitt Sicherheitsgruppe gelangen.

Von hier aus klicken Sie auf "Bestehende Sicherheitsgruppe auswählen" und unten sehen Sie alle Sicherheitsgruppen, die Sie für diese bestimmte VPC haben. Unter "Aktionen" sollte der Link "Nach Neu kopieren" angezeigt werden. Verwenden Sie diesen Link, um alle Ihre ACLs auf eine neue SG zu kopieren.

Oder ich nehme an, Sie könnten ein Skript verwenden - das ist IMO schneller.

Ich hatte ein ähnliches Problem, aber ich habe SG über verschiedene Konten hinweg kopiert.

Geben Sie einfach zu Beginn einige CONSTANTS an, und die Funktion copy_sg kopiert sie.

Es findet keine Fehlerprüfung statt. Wenn die Ziel-SG bereits vorhanden ist, schlägt sie fehl.

Befolgen Sie eine allgemeine Lösung, die auch innerhalb eines Kontos verwendet werden kann:

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