

# Administración de grupos de seguridad con CloudFormation
<a name="quickref-ec2-sg"></a>

Los siguientes fragmentos muestran cómo usar CloudFormation para administrar los grupos de seguridad y las instancias de Amazon EC2 para controlar el acceso a sus recursos de AWS.

**Topics**
+ [Asociación de una instancia de Amazon EC2 con un grupo de seguridad](#quickref-ec2-instances-associate-security-group)
+ [Creación de grupos de seguridad con reglas de entrada](#quickref-ec2-instances-ingress)
+ [Creación de un equilibrador de carga elástica con una regla de ingreso de grupos de seguridad](#scenario-ec2-security-group-elbingress)

## Asociación de una instancia de Amazon EC2 con un grupo de seguridad
<a name="quickref-ec2-instances-associate-security-group"></a>

Los siguientes fragmentos de ejemplo muestran cómo asociar una instancia de Amazon EC2 a un grupo de seguridad de Amazon VPC predeterminado mediante CloudFormation.

**Topics**
+ [Asociación de una instancia de Amazon EC2 con un grupo de seguridad de VPN predeterminado](#using-cfn-getatt-default-values)
+ [Creación de una instancia de Amazon EC2 con un volumen y un grupo de seguridad adjuntos](#scenario-ec2-volumeattachment)

### Asociación de una instancia de Amazon EC2 con un grupo de seguridad de VPN predeterminado
<a name="using-cfn-getatt-default-values"></a>

El siguiente fragmento crea una VPC de Amazon, una subred dentro de la VPC y una instancia de Amazon EC2. La VPC se crea con un recurso [AWS::EC2::VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpc.html). El rango de direcciones IP de la VPC se define en la plantilla más grande y el parámetro `MyVPCCIDRRange` hace referencia a él.

Se crea una subred dentro de la VPC con un recurso de subred [AWS::EC2::Subnet](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-subnet.html). La subred está asociada a la VPC, a la que se hace referencia como `MyVPC`.

Se lanza una instancia de EC2 dentro de la VPC y la subred mediante un recurso [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html). Este recurso especifica la imagen de máquina de Amazon (AMI) que se utilizará para lanzar la instancia, la subred en la que se ejecutará la instancia y el grupo de seguridad que se asociará a la instancia. `ImageId` utiliza un parámetro de Systems Manager para recuperar de forma dinámica la AMI más reciente de Amazon Linux 2. 

El ID del grupo de seguridad se obtiene mediante la función `Fn::GetAtt`, que recupera el grupo de seguridad predeterminado del recurso `MyVPC`. 

La instancia se coloca dentro del recurso `MySubnet` definido en el fragmento. 

Al crear una VPC con CloudFormation, AWS crea automáticamente recursos predeterminados dentro de la VPC, incluido un grupo de seguridad predeterminado. Sin embargo, al definir una VPC dentro de una plantilla de CloudFormation, es posible que no tenga acceso a los ID de estos recursos predeterminados al crear la plantilla. Para acceder a los recursos predeterminados especificados en la plantilla y utilizarlos, puede utilizar funciones intrínsecas, como `Fn::GetAtt`. Esta función le permite trabajar con los recursos predeterminados que CloudFormation crea automáticamente.

#### JSON
<a name="quickref-ec2-example-15.json"></a>

```
"MyVPC": {
    "Type": "AWS::EC2::VPC",
    "Properties": {
        "CidrBlock": {
            "Ref": "MyVPCCIDRRange"
        },
        "EnableDnsSupport": false,
        "EnableDnsHostnames": false,
        "InstanceTenancy": "default"
    }
},
"MySubnet": {
    "Type": "AWS::EC2::Subnet",
    "Properties": {
        "CidrBlock": {
            "Ref": "MyVPCCIDRRange"
        },
        "VpcId": {
            "Ref": "MyVPC"
        }
    }
},
"MyInstance": {
    "Type": "AWS::EC2::Instance",
    "Properties": {
        "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
        "SecurityGroupIds": [
            {
                "Fn::GetAtt": [
                    "MyVPC",
                    "DefaultSecurityGroup"
                ]
            }
        ],
        "SubnetId": {
            "Ref": "MySubnet"
        }
    }
}
```

#### YAML
<a name="quickref-ec2-example-15.yaml"></a>

```
MyVPC:
  Type: AWS::EC2::VPC
  Properties:
    CidrBlock:
      Ref: MyVPCCIDRRange
    EnableDnsSupport: false
    EnableDnsHostnames: false
    InstanceTenancy: default
MySubnet:
  Type: AWS::EC2::Subnet
  Properties:
    CidrBlock:
      Ref: MyVPCCIDRRange
    VpcId:
      Ref: MyVPC
MyInstance:
  Type: AWS::EC2::Instance
  Properties:
    ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
    SecurityGroupIds:
      - Fn::GetAtt:
          - MyVPC
          - DefaultSecurityGroup
    SubnetId:
      Ref: MySubnet
```

### Creación de una instancia de Amazon EC2 con un volumen y un grupo de seguridad adjuntos
<a name="scenario-ec2-volumeattachment"></a>

El siguiente fragmento de código crea una instancia de Amazon EC2 con un recurso [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html), que se inicia desde una AMI designada. La instancia está asociada a un grupo de seguridad que permite el tráfico SSH entrante en el puerto 22 desde una dirección IP específica, mediante un recurso [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html). Crea un volumen de Amazon EBS de 100 GB mediante un recurso [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html). El volumen se crea en la misma zona de disponibilidad que la instancia, según lo especifique la función `GetAtt`, y se monta en la instancia del dispositivo `/dev/sdh`.

Para más información sobre la creación de una instantánea en EBS, consulte [Creación de un volumen de Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html).

#### JSON
<a name="quickref-ec2-example-14.json"></a>

```
 1. "Ec2Instance": {
 2.     "Type": "AWS::EC2::Instance",
 3.     "Properties": {
 4.         "SecurityGroups": [
 5.             {
 6.                 "Ref": "InstanceSecurityGroup"
 7.             }
 8.         ],
 9.         "ImageId": "ami-1234567890abcdef0"
10.     }
11. },
12. "InstanceSecurityGroup": {
13.     "Type": "AWS::EC2::SecurityGroup",
14.     "Properties": {
15.         "GroupDescription": "Enable SSH access via port 22",
16.         "SecurityGroupIngress": [
17.             {
18.                 "IpProtocol": "tcp",
19.                 "FromPort": "22",
20.                 "ToPort": "22",
21.                 "CidrIp": "192.0.2.0/24"
22.             }
23.         ]
24.     }
25. },
26. "NewVolume": {
27.     "Type": "AWS::EC2::Volume",
28.     "Properties": {
29.         "Size": "100",
30.         "AvailabilityZone": {
31.             "Fn::GetAtt": [
32.                 "Ec2Instance",
33.                 "AvailabilityZone"
34.             ]
35.         }
36.     }
37. },
38. "MountPoint": {
39.     "Type": "AWS::EC2::VolumeAttachment",
40.     "Properties": {
41.         "InstanceId": {
42.             "Ref": "Ec2Instance"
43.         },
44.         "VolumeId": {
45.             "Ref": "NewVolume"
46.         },
47.         "Device": "/dev/sdh"
48.     }
49. }
```

#### YAML
<a name="quickref-ec2-example-14.yaml"></a>

```
 1. Ec2Instance:
 2.   Type: AWS::EC2::Instance
 3.   Properties:
 4.     SecurityGroups:
 5.       - !Ref InstanceSecurityGroup
 6.     ImageId: ami-1234567890abcdef0
 7. InstanceSecurityGroup:
 8.   Type: AWS::EC2::SecurityGroup
 9.   Properties:
10.     GroupDescription: Enable SSH access via port 22
11.     SecurityGroupIngress:
12.       - IpProtocol: tcp
13.         FromPort: 22
14.         ToPort: 22
15.         CidrIp: 192.0.2.0/24
16. NewVolume:
17.   Type: AWS::EC2::Volume
18.   Properties:
19.     Size: 100
20.     AvailabilityZone: !GetAtt [Ec2Instance, AvailabilityZone]
21. MountPoint:
22.   Type: AWS::EC2::VolumeAttachment
23.   Properties:
24.     InstanceId: !Ref Ec2Instance
25.     VolumeId: !Ref NewVolume
26.     Device: /dev/sdh
```

## Creación de grupos de seguridad con reglas de entrada
<a name="quickref-ec2-instances-ingress"></a>

En los siguientes fragmentos de ejemplo, se muestra cómo configurar grupos de seguridad con reglas de entrada específicas mediante CloudFormation.

**Topics**
+ [Creación de un grupo de seguridad con reglas de entrada para el acceso SSH y HTTP](#scenario-ec2-security-group-rule)
+ [Creación de un grupo de seguridad con reglas de entrada para el acceso SSH y HTTP a partir de rangos CIDR especificados](#scenario-ec2-security-group-two-ports)
+ [Creación de grupos de seguridad de referencia cruzada con reglas de entrada](#scenario-ec2-security-group-ingress)

### Creación de un grupo de seguridad con reglas de entrada para el acceso SSH y HTTP
<a name="scenario-ec2-security-group-rule"></a>

Este fragmento de código muestra un recurso [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) que describe dos reglas de entrada del grupo de seguridad. La primera regla de entrada permite el acceso SSH (puerto 22) desde un grupo de seguridad existente denominado `MyAdminSecurityGroup`, que es propiedad de la cuenta de AWS con el número de cuenta `1111-2222-3333`. La segunda regla de entrada permite el acceso HTTP (puerto 80) desde un grupo de seguridad diferente denominado `MySecurityGroupCreatedInCFN`, que se crea en la misma plantilla. La función `Ref` se utiliza para hacer referencia al nombre lógico del grupo de seguridad creado en la misma plantilla. 

En la primera regla de entrada, debe agregar un valor para las propiedades `SourceSecurityGroupName` y `SourceSecurityGroupOwnerId`. En la segunda regla de entrada, `MySecurityGroupCreatedInCFNTemplate` hace referencia a un grupo de seguridad diferente, que se crea en la misma plantilla. Compruebe que el nombre lógico `MySecurityGroupCreatedInCFNTemplate` coincide con el nombre lógico real del recurso del grupo de seguridad que especificó en la plantilla más grande. 

Para obtener más información sobre los grupos de seguridad, consulte [Grupos de seguridad de Amazon EC2 para instancias de EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) en la *Guía del usuario de Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-10.json"></a>

```
 1. "SecurityGroup": {
 2.     "Type": "AWS::EC2::SecurityGroup",
 3.     "Properties": {
 4.         "GroupDescription": "Allow connections from specified source security group",
 5.         "SecurityGroupIngress": [
 6.             {
 7.                 "IpProtocol": "tcp",
 8.                 "FromPort": "22",
 9.                 "ToPort": "22",
10.                 "SourceSecurityGroupName": "MyAdminSecurityGroup",
11.                 "SourceSecurityGroupOwnerId": "1111-2222-3333"
12.             },
13.             {
14.                 "IpProtocol": "tcp",
15.                 "FromPort": "80",
16.                 "ToPort": "80",
17.                 "SourceSecurityGroupName": {
18.                     "Ref": "MySecurityGroupCreatedInCFNTemplate"
19.                 }
20.             }
21.         ]
22.     }
23. }
```

#### YAML
<a name="quickref-ec2-example-10.yaml"></a>

```
 1. SecurityGroup:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: Allow connections from specified source security group
 5.     SecurityGroupIngress:
 6.       - IpProtocol: tcp
 7.         FromPort: '22'
 8.         ToPort: '22'
 9.         SourceSecurityGroupName: MyAdminSecurityGroup
10.         SourceSecurityGroupOwnerId: '1111-2222-3333'
11.       - IpProtocol: tcp
12.         FromPort: '80'
13.         ToPort: '80'
14.         SourceSecurityGroupName:
15.           Ref: MySecurityGroupCreatedInCFNTemplate
```

### Creación de un grupo de seguridad con reglas de entrada para el acceso SSH y HTTP a partir de rangos CIDR especificados
<a name="scenario-ec2-security-group-two-ports"></a>

El siguiente fragmento crea un grupo de seguridad para una instancia de Amazon EC2 con dos reglas de entrada. Las reglas de entrada permiten el tráfico TCP entrante en los puertos especificados desde los rangos de CIDR designados. Se utiliza un recurso [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) para especificar las reglas. Debe especificar un protocolo para cada regla. En el caso de TCP, también debe especificar un puerto o intervalo de puertos. Si no especifica un grupo de seguridad de origen o un rango de CIDR, la pila se iniciará correctamente, pero la regla no se aplicará al grupo de seguridad. 

Para obtener más información sobre los grupos de seguridad, consulte [Grupos de seguridad de Amazon EC2 para instancias de EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) en la *Guía del usuario de Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-9.json"></a>

```
 1. "ServerSecurityGroup": {
 2.   "Type": "AWS::EC2::SecurityGroup",
 3.   "Properties": {
 4.     "GroupDescription": "Allow connections from specified CIDR ranges",
 5.     "SecurityGroupIngress": [
 6.       {
 7.         "IpProtocol": "tcp",
 8.         "FromPort": "80",
 9.         "ToPort": "80",
10.         "CidrIp": "192.0.2.0/24"
11.       },
12.       {
13.         "IpProtocol": "tcp",
14.         "FromPort": "22",
15.         "ToPort": "22",
16.         "CidrIp": "192.0.2.0/24"
17.       }
18.     ]
19.   }
20. }
```

#### YAML
<a name="quickref-ec2-example-9.yaml"></a>

```
 1. ServerSecurityGroup:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: Allow connections from specified CIDR ranges
 5.     SecurityGroupIngress:
 6.       - IpProtocol: tcp
 7.         FromPort: 80
 8.         ToPort: 80
 9.         CidrIp: 192.0.2.0/24
10.       - IpProtocol: tcp
11.         FromPort: 22
12.         ToPort: 22
13.         CidrIp: 192.0.2.0/24
```

### Creación de grupos de seguridad de referencia cruzada con reglas de entrada
<a name="scenario-ec2-security-group-ingress"></a>

El siguiente fragmento de código utiliza el recurso [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) para crear dos grupos de seguridad de Amazon EC2, `SGroup1` y `SGroup2`. Las reglas de ingreso que permiten la comunicación entre los dos grupos de seguridad se crean mediante el recurso [AWS::EC2::SecurityGroupIngress](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroupingress.html). `SGroup1Ingress` establece una regla de entrada para `SGroup1` que permite el tráfico TCP entrante en el puerto 80 desde el grupo de seguridad de origen, `SGroup2`. `SGroup2Ingress` establece una regla de entrada para `SGroup2` que permite el tráfico TCP entrante en el puerto 80 desde el grupo de seguridad de origen, `SGroup1`. 

#### JSON
<a name="quickref-ec2-example-12.json"></a>

```
 1. "SGroup1": {
 2.     "Type": "AWS::EC2::SecurityGroup",
 3.     "Properties": {
 4.         "GroupDescription": "EC2 instance access"
 5.     }
 6. },
 7. "SGroup2": {
 8.     "Type": "AWS::EC2::SecurityGroup",
 9.     "Properties": {
10.         "GroupDescription": "EC2 instance access"
11.     }
12. },
13. "SGroup1Ingress": {
14.     "Type": "AWS::EC2::SecurityGroupIngress",
15.     "Properties": {
16.         "GroupName": {
17.             "Ref": "SGroup1"
18.         },
19.         "IpProtocol": "tcp",
20.         "ToPort": "80",
21.         "FromPort": "80",
22.         "SourceSecurityGroupName": {
23.             "Ref": "SGroup2"
24.         }
25.     }
26. },
27. "SGroup2Ingress": {
28.     "Type": "AWS::EC2::SecurityGroupIngress",
29.     "Properties": {
30.         "GroupName": {
31.             "Ref": "SGroup2"
32.         },
33.         "IpProtocol": "tcp",
34.         "ToPort": "80",
35.         "FromPort": "80",
36.         "SourceSecurityGroupName": {
37.             "Ref": "SGroup1"
38.         }
39.     }
40. }
```

#### YAML
<a name="quickref-ec2-example-12.yaml"></a>

```
 1. SGroup1:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: EC2 Instance access
 5. SGroup2:
 6.   Type: AWS::EC2::SecurityGroup
 7.   Properties:
 8.     GroupDescription: EC2 Instance access
 9. SGroup1Ingress:
10.   Type: AWS::EC2::SecurityGroupIngress
11.   Properties:
12.     GroupName: !Ref SGroup1
13.     IpProtocol: tcp
14.     ToPort: 80
15.     FromPort: 80
16.     SourceSecurityGroupName: !Ref SGroup2
17. SGroup2Ingress:
18.   Type: AWS::EC2::SecurityGroupIngress
19.   Properties:
20.     GroupName: !Ref SGroup2
21.     IpProtocol: tcp
22.     ToPort: 80
23.     FromPort: 80
24.     SourceSecurityGroupName: !Ref SGroup1
```

## Creación de un equilibrador de carga elástica con una regla de ingreso de grupos de seguridad
<a name="scenario-ec2-security-group-elbingress"></a>

La siguiente plantilla crea un recurso [AWS::ElasticLoadBalancing::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancing-loadbalancer.html) en la zona de disponibilidad especificada. El recurso [AWS::ElasticLoadBalancing::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancing-loadbalancer.html) está configurado para escuchar el tráfico HTTP en el puerto 80 y dirigir las solicitudes a las instancias también en el puerto 80. El equilibrador de carga elástico es responsable de equilibrar la carga del tráfico HTTP entrante entre las instancias.

 Además, esta plantilla genera un recurso [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) asociado al equilibrador de carga. Este grupo de seguridad se crea con una única regla de entrada, descrita como `ELB ingress group`, que permite el tráfico TCP entrante en el puerto 80. El origen de esta regla de entrada se define mediante la función `Fn::GetAtt` para recuperar los atributos del recurso del equilibrador de carga. `SourceSecurityGroupOwnerId` utiliza `Fn::GetAtt` para obtener el grupo de seguridad `OwnerAlias` del equilibrador de carga. `SourceSecurityGroupName` utiliza `Fn::Getatt` para obtener el `GroupName` del grupo de seguridad de origen del ELB. 

Esta configuración garantiza una comunicación segura entre el ELB y las instancias. 

Para obtener más información sobre balanceadores de carga, consulte la [Guía del usuario de Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).

### JSON
<a name="quickref-ec2-example-11.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "MyELB": {
            "Type": "AWS::ElasticLoadBalancing::LoadBalancer",
            "Properties": {
                "AvailabilityZones": [
                    "aa-example-1a"
                ],
                "Listeners": [
                    {
                        "LoadBalancerPort": "80",
                        "InstancePort": "80",
                        "Protocol": "HTTP"
                    }
                ]
            }
        },
        "MyELBIngressGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "ELB ingress group",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "SourceSecurityGroupOwnerId": {
                            "Fn::GetAtt": [
                                "MyELB",
                                "SourceSecurityGroup.OwnerAlias"
                            ]
                        },
                        "SourceSecurityGroupName": {
                            "Fn::GetAtt": [
                                "MyELB",
                                "SourceSecurityGroup.GroupName"
                            ]
                        }
                    }
                ]
            }
        }
    }
}
```

### YAML
<a name="quickref-ec2-example-11.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  MyELB:
    Type: AWS::ElasticLoadBalancing::LoadBalancer
    Properties:
      AvailabilityZones:
        - aa-example-1a
      Listeners:
        - LoadBalancerPort: '80'
          InstancePort: '80'
          Protocol: HTTP
  MyELBIngressGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: ELB ingress group
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: '80'
          ToPort: '80'
          SourceSecurityGroupOwnerId:
            Fn::GetAtt:
              - MyELB
              - SourceSecurityGroup.OwnerAlias
          SourceSecurityGroupName:
            Fn::GetAtt:
              - MyELB
              - SourceSecurityGroup.GroupName
```