¿Es posible copiar un grupo de seguridad de AWS?

Tenemos algunos grupos de seguridad que tienen bastantes reglas en ellos. En lugar de tener que recrear las mismas reglas para varios grupos de seguridad solo para acomodar diferencias menores, ¿es posible copiar un grupo de seguridad para usarlo como punto de partida, o usar herencia, etc.?

No parece que pueda copiar grupos de seguridad desde la interfaz web. Sin embargo, puede usar la CLI de AWS para crear grupos de seguridad :

Comando:

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

Salida:

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

Y agregue reglas usando el 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

Salida:

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

A partir de ahí, debería poder descubrir cómo simplificar la creación de sus grupos de seguridad.

La consola AWS EC2 le permite seleccionar el grupo de seguridad y realizar la operación "Copiar a nuevo" en la IU ahora.

Desde AWS Creación de documentos de un grupo de seguridad, puede copiar un grupo de seguridad utilizando la consola.

1. Seleccione el grupo de seguridad que desea copiar
2. Elige Acción
3. Copiar a nuevo

Considera echar un vistazo a este blog. Puede ser útil para lo que estás viendo.

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

Aquí está el método python / boto de 'copiar grupos de seguridad' de una biblioteca personalizada que escribí para facilitar este tipo de cosas / automatizarlas ... Finalmente, esta fue la solución que se me ocurrió.

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

El resto debe ser sencillo de entender.

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 

Aquí está el script que hice para lograr esto: aws_sg_migrate

El uso de la muestra es

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

Está basado en este y adaptado para Python3.

Dentro de la misma región de AWS, puede copiar una política de seguridad utilizando la GUI en línea. Sin embargo, a veces quieres copiar cosas mediante programación. Por ejemplo, si tiene muchas políticas de seguridad para copiar o si desea copiar entre regiones.

Aquí hay un fragmento simple para hacer eso.

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

Debido a la falta de una forma adecuada de hacer esto en línea, creé un script súper simple para manejarlo. Echa un vistazo si estás interesado.

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

Desde la consola EC2, haga clic en Iniciar instancia y proceda a ingresar la información ficticia hasta llegar a la sección del grupo de seguridad.

Desde aquí, haga clic en "Seleccionar un grupo de seguridad existente", y debajo verá todos los grupos de seguridad que tiene para esa VPC en particular. Debería ver un enlace "Copiar a nuevo" en "Acciones", use esto para copiar todas sus ACL a una nueva SG.

O supongo que podría usar una secuencia de comandos: esta es una OMI más rápida.

Tuve un problema similar pero copiando SG en diferentes cuentas.

Simplemente especifique algunas CONSTANTES al principio y la función copy_sg las copiará.

No se ha realizado ninguna verificación de error, por lo tanto, si el SG objetivo ya existe, fallará.

Siga una solución general que se puede usar también dentro de la cuenta:

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