# Ejemplos de políticas basadas en identidad de IAM
Una [política](access_policies.md) es un objeto de AWS que, cuando se asocia a una identidad o un recurso, define sus permisos. AWS evalúa estas políticas cuando una entidad principal de IAM (usuario o rol) realiza una solicitud. Los permisos en las políticas determinan si la solicitud se permite o se deniega. La mayoría de políticas se almacenan en AWS como documentos JSON que se asocian a una identidad de IAM (usuario, grupo de usuarios o rol). Las políticas basadas en la identidad incluyen políticas administradas por AWS, políticas administradas por el cliente y políticas insertadas. Para obtener información sobre cómo crear una política de IAM mediante estos documentos de políticas JSON de ejemplo, consulte [Creación de políticas mediante el editor JSON](access_policies_create-console.md#access_policies_create-json-editor).
De forma predeterminada, todas las solicitudes se deniegan, por lo que debe proporcionar acceso a los servicios, acciones y recursos que piensa utilizar para la identidad de acceso. Si también quiere permitir el acceso para completar las acciones especificadas en la consola de IAM, debe proporcionar permisos adicionales.
La siguiente biblioteca de políticas puede serle útil para definir permisos para las identidades de IAM. Después de encontrar la política que necesita, seleccione **View this policy (Ver esta política)** para ver el JSON de la política. Puede utilizar el documento de política JSON como plantilla de sus propias políticas.
**nota**
Si desea enviar una política para que se incluya en esta guía de referencia, utilice el botón **Feedback (Comentarios)** de la parte inferior de esta página.
## Ejemplos de políticas: AWS
+ Permite el acceso durante un intervalo de fechas específico. ([Ver esta política](reference_policies_examples_aws-dates.md)).
+ Permite la habilitación y deshabilitación de regiones de AWS. ([Ver esta política](reference_policies_examples_aws-enable-disable-regions.md)).
+ Permite a los usuarios autenticados por MFA administrar las credenciales propias en la página **Mis credenciales de seguridad**. ([Ver esta política](reference_policies_examples_aws_my-sec-creds-self-manage.md)).
+ Permite el acceso específico cuando se usa MFA en un intervalo específico de fechas. ([Ver esta política](reference_policies_examples_aws_mfa-dates.md)).
+ Permite a los usuarios administrar las credenciales propias en la página **Mis credenciales de seguridad**. ([Ver esta política](reference_policies_examples_aws_my-sec-creds-self-manage-no-mfa.md)).
+ Permite a los usuarios administrar los dispositivos MFA propios en la página **Mis credenciales de seguridad**. ([Ver esta política](reference_policies_examples_aws_my-sec-creds-self-manage-mfa-only.md)).
+ Permite a los usuarios administrar las contraseñas propias en la página **Mis credenciales de seguridad**. ([Ver esta política](reference_policies_examples_aws_my-sec-creds-self-manage-password-only.md)).
+ Permite a los usuarios administrar las contraseñas, las claves de acceso y las claves públicas SSH propias en la página **Mis credenciales de seguridad**. ([Ver esta política](reference_policies_examples_aws_my-sec-creds-self-manage-pass-accesskeys-ssh.md)).
+ Deniega el acceso a AWS en función de la región solicitada. ([Ver esta política](reference_policies_examples_aws_deny-requested-region.md)).
+ Deniega el acceso a AWS en función de la dirección IP de origen. ([Ver esta política](reference_policies_examples_aws_deny-ip.md)).
## Política de ejemplo: AWS Data Exchange
+ Deniega el acceso a los recursos de Amazon S3 fuera de su cuenta, excepto AWS Data Exchange. ([Ver esta política](reference_policies_examples_resource_account_data_exch.md)).
## Ejemplos de políticas: AWS Data Pipeline
+ Deniega el acceso a canalizaciones que el usuario no ha creado ([ver esta política](reference_policies_examples_datapipeline_not-owned.md)).
## Políticas de ejemplo: Amazon DynamoDB
+ Permite el acceso a una tabla de Amazon DynamoDB específica ([ver esta política](reference_policies_examples_dynamodb_specific-table.md)).
+ Permite el acceso a atributos de Amazon DynamoDB específicos ([ver esta política](reference_policies_examples_dynamodb_attributes.md)).
+ Permite el acceso de elementos a Amazon DynamoDB en función del ID de Amazon Cognito ([ver esta política](reference_policies_examples_dynamodb_items.md)).
## Políticas de ejemplo: Amazon EC2
+ Permite asociar o separar volúmenes de Amazon EBS a instancias de Amazon EC2 en función de las etiquetas ([ver esta política](reference_policies_examples_ec2_ebs-owner.md)).
+ Permite lanzar instancias de Amazon EC2 en una determinada subred, mediante programación, y en la consola ([ver esta política](reference_policies_examples_ec2_instances-subnet.md))
+ Permite administrar grupos de seguridad de Amazon EC2 asociados a una VPC específica, mediante programación y en la consola ([ver esta política](reference_policies_examples_ec2_securitygroups-vpc.md)).
+ Permite iniciar o detener instancias de Amazon EC2 que un usuario haya etiquetado, mediante programación y en la consola ([ver esta política](reference_policies_examples_ec2_tag-owner.md)).
+ Permite iniciar o detener instancias de Amazon EC2 en función de las etiquetas de recursos y entidades principales, mediante programación y en la consola ([ver esta política](reference_policies_examples_ec2-start-stop-tags.md)).
+ Permite iniciar o detener instancias de Amazon EC2 cuando las etiquetas de recursos y entidades principales coincidan ([ver esta política](reference_policies_examples_ec2-start-stop-match-tags.md)).
+ Permite el acceso completo a Amazon EC2 en una región determinada, mediante programación y en la consola. ([Ver esta política](reference_policies_examples_ec2_region.md)).
+ Permite iniciar o detener una instancia de Amazon EC2 concreta y modificar un grupo de seguridad específico, mediante programación y en la consola ([ver esta política](reference_policies_examples_ec2_instance-securitygroup.md))
+ Deniega el acceso a operaciones de Amazon EC2 específicas sin MFA ([ver esta política](reference_policies_examples_ec2_require-mfa.md)).
+ Limita la terminación de instancias de Amazon EC2 a un rango específico de direcciones IP ([ver esta política](reference_policies_examples_ec2_terminate-ip.md))
## Ejemplos de políticas: AWS Identity and Access Management (IAM)
+ Permite el acceso a la API del simulador de políticas ([ver esta política](reference_policies_examples_iam_policy-sim.md)).
+ Permite el acceso a la consola del simulador de políticas ([ver esta política](reference_policies_examples_iam_policy-sim-console.md)).
+ Permite asumir cualquier rol que tenga una etiqueta específica, mediante programación y en la consola ([ver esta política)](reference_policies_examples_iam-assume-tagged-role.md).
+ Permite y deniega el acceso a varios servicios, mediante programación y en la consola ([ver esta política)](reference_policies_examples_iam_multiple-services-console.md).
+ Permite agregar una etiqueta específica a un usuario de IAM con otra etiqueta específica, mediante programación y en la consola ([ver esta política](reference_policies_examples_iam-add-tag.md)).
+ Permite agregar una etiqueta específica a cualquier usuario o rol de IAM, mediante programación y en la consola ([ver esta política](reference_policies_examples_iam-add-tag-user-role.md)).
+ Permite crear un nuevo usuario solo con etiquetas específicas ([ver esta política](reference_policies_examples_iam-new-user-tag.md)).
+ Permite generar y recuperar informes de credenciales de IAM ([ver esta política](reference_policies_examples_iam-credential-report.md)).
+ Permite administrar la pertenencia a un grupo, mediante programación y en la consola ([ver esta política)](reference_policies_examples_iam_manage-group-membership.md).
+ Permite administrar una etiqueta específica ([ver esta política](reference_policies_examples_iam-manage-tags.md)).
+ Permite transferir un rol de IAM a un servicio específico ([ver esta política](reference_policies_examples_iam-passrole-service.md)).
+ Permite acceso de solo lectura a la consola de IAM sin informes ([ver esta política](reference_policies_examples_iam_read-only-console-no-reporting.md)).
+ Permite acceso de solo lectura a la consola de IAM ([ver esta política](reference_policies_examples_iam_read-only-console.md)).
+ Permite que usuarios específicos administren un grupo, mediante programación y en la consola ([ver esta política)](reference_policies_examples_iam_users-manage-group.md).
+ Permite establecer los requisitos de contraseña de la cuenta, mediante programación y en la consola ([ver esta política)](reference_policies_examples_iam_set-account-pass-policy.md).
+ Permite utilizar la API del simulador de políticas para los usuarios con una ruta específica ([ver esta política](reference_policies_examples_iam_policy-sim-path.md)).
+ Permite utilizar la consola del simulador de políticas para los usuarios con una ruta específica ([ver esta política](reference_policies_examples_iam_policy-sim-path-console.md)).
+ Permite a los usuarios de IAM administrar ellos mismos un dispositivo MFA. ([Ver esta política](reference_policies_examples_iam_mfa-selfmanage.md)).
+ Permite a los usuarios de IAM definir sus propias credenciales, mediante programación y en la consola. ([Ver esta política](reference_policies_examples_iam_credentials_console.md)).
+ Permite ver la información de acceso reciente de una política de AWS Organizations en la consola de IAM. ([Ver esta política](reference_policies_examples_iam_service-accessed-data-orgs.md)).
+ Limita las políticas administradas que pueden aplicarse a un usuario, grupo o rol de IAM ([ver esta política](reference_policies_examples_iam_limit-managed.md)).
+ Permite el acceso a las políticas de IAM solo en su cuenta ([Ver esta política](resource_examples_iam_policies_resource_account.md)).
## Ejemplos de políticas: AWS Lambda
+ Permite que la función de AWS Lambda obtenga acceso a una tabla de Amazon DynamoDB ([ver esta política](reference_policies_examples_lambda-access-dynamodb.md)).
## Políticas de ejemplo: Amazon RDS
+ Permite acceso completo a la base de datos de Amazon RDS dentro de una región específica. ([Ver esta política](reference_policies_examples_rds_region.md)).
+ Permite restaurar bases de datos de Amazon RDS, mediante programación y en la consola ([ver esta política](reference_policies_examples_rds_db-console.md))
+ Permite a los propietarios de etiquetas el acceso completo a los recursos de Amazon RDS que han etiquetado ([ver esta política](reference_policies_examples_rds_tag-owner.md))
## Políticas de ejemplo: Amazon S3
+ Permite que un usuario de Amazon Cognito obtenga acceso a los objetos en su propio bucket de Amazon S3 ([ver esta política](reference_policies_examples_s3_cognito-bucket.md))
+ Permite que un usuario con credenciales temporales acceda a su propio directorio principal en Amazon S3, tanto mediante programación como desde la consola ([Ver esta política](reference_policies_examples_s3_federated-home-directory-console.md)).
+ Permite acceso S3 completo, pero deniega de forma explícita el acceso al bucket de producción en caso de que el administrador no haya iniciado sesión utilizando MFA en los últimos treinta minutos ([ver esta política)](reference_policies_examples_s3_full-access-except-production.md).
+ Permite que los usuarios de IAM obtengan acceso a su propio directorio de inicio en Amazon S3, mediante programación y en la consola ([ver esta política](reference_policies_examples_s3_home-directory-console.md))
+ Permite que un usuario administre un único bucket de Amazon S3 y deniega todas las demás acciones y recursos de AWS ([ver esta política](reference_policies_examples_s3_deny-except-bucket.md)).
+ Permite el acceso de `Read` y `Write` a un bucket de Amazon S3 específico ([ver esta política](reference_policies_examples_s3_rw-bucket.md))
+ Permite el acceso de `Read` y `Write` a un bucket de Amazon S3 específico, mediante programación, y en la consola ([ver esta política](reference_policies_examples_s3_rw-bucket-console.md))
# AWS: permite el acceso en función de la fecha y la hora
En este ejemplo se muestra cómo crear una política basada en identidad que permite el acceso a acciones según la fecha y hora. Esta política restringe el acceso a las acciones que se produzcan entre el 1 de abril de 2020 y el 30 de junio de 2020 (UTC), ambos inclusive. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Para obtener información acerca de la utilización de varias condiciones dentro del bloque `Condition` de una política de IAM, consulte [Múltiples valores en un elemento Condition](reference_policies_elements_condition.md#Condition-multiple-conditions).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "service-prefix:action-name",
"Resource": "*",
"Condition": {
"DateGreaterThan": {"aws:CurrentTime": "2020-04-01T00:00:00Z"},
"DateLessThan": {"aws:CurrentTime": "2020-06-30T23:59:59Z"}
}
}
]
}
```
------
**nota**
No puede utilizar una variable de política con el operador de condición de fecha. Para obtener más información, consulte [Elemento de condición](reference_policies_variables.md#policy-vars-conditionelement)
# AWS: permite habilitar y deshabilitar regiones de AWS
Este ejemplo muestra cómo puede crear una política basada en identidad que permita a un administrador activar y desactivar la Región Asia-Pacífico (Hong Kong) (ap-east-1). Esta política define los permisos para el acceso programático y a la consola. Esta configuración aparece en la página **Account settings (Configuración de la cuenta)** en la Consola de administración de AWS. Esta página incluye información de nivel de cuenta sensible que debe visualizar y administrar únicamente los administradores de cuentas. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
**importante**
No puede habilitar ni deshabilitar las regiones habilitadas de forma predeterminada. Solo puede incluir las regiones que están *deshabilitadas* de forma predeterminada. Para obtener más información, consulte [Administración de las regiones de AWS](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html) en la *Referencia general de AWS*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnableDisableHongKong",
"Effect": "Allow",
"Action": [
"account:EnableRegion",
"account:DisableRegion"
],
"Resource": "*",
"Condition": {
"StringEquals": {"account:TargetRegion": "ap-east-1"}
}
},
{
"Sid": "ViewConsole",
"Effect": "Allow",
"Action": [
"account:ListRegions"
],
"Resource": "*"
}
]
}
```
------
# AWS: permite a los usuarios de IAM autenticados por MFA administrar sus propias credenciales en la página Credenciales de seguridad
En este ejemplo, se muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM autenticados mediante [autenticación multifactor (MFA)](id_credentials_mfa.md) administrar sus propias credenciales en la página **Credenciales de seguridad**. En esta página de la Consola de administración de AWS, se muestra información de la cuenta, como el ID de cuenta y el ID de usuario canónico. Los usuarios también pueden ver y editar sus propias contraseñas, claves de acceso, dispositivos MFA, certificados X.509, claves SSH y credenciales de Git. Esta política de ejemplo incluye los permisos necesarios para ver y editar toda la información de la página. También requiere que el usuario se configure y autentique con MFA para poder realizar cualquier otra operación en AWS. Para permitir a los usuarios administrar sus propias credenciales sin utilizar MFA, consulte [AWS: permite a los usuarios de IAM administrar sus propias credenciales en la página Credenciales de seguridad](reference_policies_examples_aws_my-sec-creds-self-manage-no-mfa.md).
Para información sobre el acceso a la página **Credenciales de seguridad**, consulte [Cómo cambian los usuarios de IAM su propia contraseña (consola)](id_credentials_passwords_user-change-own.md#ManagingUserPwdSelf-Console).
**nota**
Este ejemplo de política no permite a los usuarios restablecer una contraseña al iniciar sesión en la Consola de administración de AWS por primera vez. Recomendamos que no conceda permisos a los nuevos usuarios hasta después de que inicien sesión. Para obtener más información, consulte [¿Cómo puedo crear usuarios de IAM de forma segura?](troubleshoot.md#troubleshoot_general_securely-create-iam-users). Esto también impide que los usuarios con una contraseña vencida restablezcan su contraseña durante el inicio de sesión. Puede permitir esto añadiendo `iam:ChangePassword` y `iam:GetAccountPasswordPolicy` a la instrucción `DenyAllExceptListedIfNoMFA`. No obstante, no lo recomendamos porque permitir a los usuarios cambiar su contraseña sin MFA puede ser un riesgo para la seguridad.
Si tiene la intención de utilizar esta política para el acceso programático, debe llamar al [https://docs.aws.amazon.com/STS/latest/APIReference/API_GetSessionToken.html](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetSessionToken.html) para autenticarse con MFA. Para obtener más información, consulte [Acceso seguro a la API con MFA](id_credentials_mfa_configure-api-require.md).
**Qué hace esta política?**
+ La instrucción `AllowViewAccountInfo` permite al usuario ver la información de nivel de cuenta. Estos permisos deben estar en su propia instrucción, ya que no admiten o no requieren un ARN de recurso. En lugar de ello, los permisos especifican `"Resource" : "*"`. Esta instrucción incluye las siguientes acciones que permiten al usuario ver información específica:
+ `GetAccountPasswordPolicy`: ver los requisitos de contraseña de la cuenta y cambiar la contraseña de su propio usuario de IAM.
+ `ListVirtualMFADevices`: ver información detallada de un dispositivo MFA virtual que está habilitado para el usuario.
+ La instrucción `AllowManageOwnPasswords` permite al usuario cambiar su propia contraseña. Esta instrucción incluye también la acción `GetUser`, que es necesaria para ver la mayor parte de la información de la página **My security credentials** (Mis credenciales de seguridad).
+ La instrucción `AllowManageOwnAccessKeys` permite al usuario crear, actualizar y eliminar sus propias claves de acceso. El usuario también puede recuperar información acerca de cuándo se utilizó por última vez la clave de acceso especificada.
+ La instrucción `AllowManageOwnSigningCertificates` permite al usuario cargar, actualizar y eliminar sus propios certificados de firma.
+ La instrucción `AllowManageOwnSSHPublicKeys` permite al usuario cargar, actualizar y eliminar sus propias claves públicas SSH de CodeCommit.
+ La instrucción `AllowManageOwnGitCredentials` permite al usuario cargar, crear y eliminar sus propias credenciales de Git de CodeCommit.
+ La declaración `AllowManageOwnVirtualMFADevice` permite al usuario crear su propio dispositivo MFA virtual. El recurso de ARN de esta declaración permite al usuario crear un dispositivo MFA con cualquier nombre, pero las otras declaraciones en la política solo permiten al usuario adjuntar el dispositivo al usuario actualmente conectado.
+ La instrucción `AllowManageOwnUserMFA` permite al usuario ver o administrar el dispositivo MFA o U2F virtual o físico de su propio usuario. El ARN de recurso de esta instrucción permite el acceso únicamente al propio usuario de IAM. Los usuarios no pueden ver ni administrar el dispositivo MFA de otros usuarios.
+ La instrucción `DenyAllExceptListedIfNoMFA` deniega el acceso a todas las acciones de todos los servicios de AWS, salvo algunas acciones indicadas, pero ***solo si*** el usuario no ha iniciado sesión con MFA. La instrucción utiliza una combinación de `"Deny"` y `"NotAction"` para denegar explícitamente el acceso a las acciones que no se indican en la lista. Esta instrucción no deniega ni permite los elementos enumerados. Son otras instrucciones de la política las que permiten las acciones. Para obtener más información acerca de la lógica de esta instrucción, consulte [NotAction con Deny](reference_policies_elements_notaction.md). Si el usuario ha iniciado sesión con MFA, la prueba `Condition` no se cumple y esta instrucción no deniega ninguna acción. En este caso, otras políticas o instrucciones determinan los permisos del usuario.
Esta instrucción garantiza que cuando el usuario no ha iniciado sesión con MFA únicamente pueda realizar las acciones que se muestran. Además, puede realizar las acciones mostradas solo si otra instrucción o política permite el acceso a estas acciones. Esto no permite a un usuario crear una contraseña durante el inicio de sesión, ya que la acción `iam:ChangePassword` no debe permitirse sin autorización de MFA.
La versión `...IfExists` del operador `Bool` garantiza que si falta la clave `aws:MultiFactorAuthPresent`, la condición devuelve el valor verdadero. Esto significa que a un usuario que accede a una API con credenciales a largo plazo, como una clave de acceso, se le deniega el acceso a las operaciones de la API que no son de IAM.
Esta política no permite a los usuarios ver la página **Usuarios** de la consola de IAM ni utilizar esa página para obtener acceso a su propia información de usuario. Para permitir esto, añada la acción `iam:ListUsers` a la instrucción `AllowViewAccountInfo` y a la instrucción `DenyAllExceptListedIfNoMFA`. Tampoco permite a los usuarios cambiar su contraseña en su propia página de usuario. Si desea permitirlo, agregue las acciones `iam:GetLoginProfile` e `iam:UpdateLoginProfile` a la instrucción `AllowManageOwnPasswords`. Para permitir también que un usuario cambie su contraseña desde su propia página de usuario sin iniciar sesión con MFA, añada la acción `iam:UpdateLoginProfile` a la instrucción `DenyAllExceptListedIfNoMFA`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowViewAccountInfo",
"Effect": "Allow",
"Action": [
"iam:GetAccountPasswordPolicy",
"iam:ListVirtualMFADevices"
],
"Resource": "*"
},
{
"Sid": "AllowManageOwnPasswords",
"Effect": "Allow",
"Action": [
"iam:ChangePassword",
"iam:GetUser"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnAccessKeys",
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:DeleteAccessKey",
"iam:ListAccessKeys",
"iam:UpdateAccessKey",
"iam:GetAccessKeyLastUsed"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnSigningCertificates",
"Effect": "Allow",
"Action": [
"iam:DeleteSigningCertificate",
"iam:ListSigningCertificates",
"iam:UpdateSigningCertificate",
"iam:UploadSigningCertificate"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnSSHPublicKeys",
"Effect": "Allow",
"Action": [
"iam:DeleteSSHPublicKey",
"iam:GetSSHPublicKey",
"iam:ListSSHPublicKeys",
"iam:UpdateSSHPublicKey",
"iam:UploadSSHPublicKey"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnGitCredentials",
"Effect": "Allow",
"Action": [
"iam:CreateServiceSpecificCredential",
"iam:DeleteServiceSpecificCredential",
"iam:ListServiceSpecificCredentials",
"iam:ResetServiceSpecificCredential",
"iam:UpdateServiceSpecificCredential"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnVirtualMFADevice",
"Effect": "Allow",
"Action": [
"iam:CreateVirtualMFADevice"
],
"Resource": "arn:aws:iam::*:mfa/*"
},
{
"Sid": "AllowManageOwnUserMFA",
"Effect": "Allow",
"Action": [
"iam:DeactivateMFADevice",
"iam:EnableMFADevice",
"iam:ListMFADevices",
"iam:ResyncMFADevice"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "DenyAllExceptListedIfNoMFA",
"Effect": "Deny",
"NotAction": [
"iam:CreateVirtualMFADevice",
"iam:EnableMFADevice",
"iam:GetUser",
"iam:GetMFADevice",
"iam:ListMFADevices",
"iam:ListVirtualMFADevices",
"iam:ResyncMFADevice",
"sts:GetSessionToken"
],
"Resource": "*",
"Condition": {
"BoolIfExists": {
"aws:MultiFactorAuthPresent": "false"
}
}
}
]
}
```
------
# AWS: permite un acceso específico mediante MFA en unas fechas específicas
En este ejemplo se muestra cómo crear una política basada en identidad que utilice varias condiciones, que se evalúan al utilizar una lógica `AND`. Permite acceso total al servicio denominado `SERVICE-NAME-1` y acceso a las acciones `ACTION-NAME-A` y `ACTION-NAME-B` en el servicio denominado `SERVICE-NAME-2`. Estas acciones están permitidas solo cuando el usuario está autenticado mediante la [autenticación multifactor (MFA)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html). El acceso está restringido a acciones que se producen entre el 1 de julio de 2017 y el 31 de diciembre de 2017 (UTC), ambos incluidos. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Para obtener información acerca de la utilización de varias condiciones dentro del bloque `Condition` de una política de IAM, consulte [Múltiples valores en un elemento Condition](reference_policies_elements_condition.md#Condition-multiple-conditions).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"service-prefix-1:*",
"service-prefix-2:action-name-a",
"service-prefix-2:action-name-b"
],
"Resource": "*",
"Condition": {
"Bool": {"aws:MultiFactorAuthPresent": true},
"DateGreaterThan": {"aws:CurrentTime": "2017-07-01T00:00:00Z"},
"DateLessThan": {"aws:CurrentTime": "2017-12-31T23:59:59Z"}
}
}
}
```
------
# AWS: permite a los usuarios de IAM administrar sus propias credenciales en la página Credenciales de seguridad
Este ejemplo muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM administrar sus propias credenciales en la página **Credenciales de seguridad**. En esta página de la Consola de administración de AWS, se muestra información de la cuenta, como el ID de cuenta y el ID de usuario canónico. Los usuarios también pueden ver y editar sus propias contraseñas, claves de acceso, certificados X.509, claves SSH y credenciales de Git. Esta política de ejemplo incluye los permisos necesarios para ver y editar toda la información de la página, *salvo* el dispositivo MFA del usuario. Para permitir a los usuarios administrar sus propias credenciales con MFA, consulte [AWS: permite a los usuarios de IAM autenticados por MFA administrar sus propias credenciales en la página Credenciales de seguridad](reference_policies_examples_aws_my-sec-creds-self-manage.md).
Para información sobre el acceso a la página **Credenciales de seguridad**, consulte [Cómo cambian los usuarios de IAM su propia contraseña (consola)](id_credentials_passwords_user-change-own.md#ManagingUserPwdSelf-Console).
**Qué hace esta política? **
+ La instrucción `AllowViewAccountInfo` permite al usuario ver la información de nivel de cuenta. Estos permisos deben estar en su propia instrucción, ya que no admiten o no requieren un ARN de recurso. En lugar de ello, los permisos especifican `"Resource" : "*"`. Esta instrucción incluye las siguientes acciones que permiten al usuario ver información específica:
+ `GetAccountPasswordPolicy`: ver los requisitos de contraseña de la cuenta y cambiar la contraseña de su propio usuario de IAM.
+ `GetAccountSummary`: ver el ID de cuenta y el [ID de usuario canónico de la cuenta](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId).
+ La instrucción `AllowManageOwnPasswords` permite al usuario cambiar su propia contraseña. Esta instrucción incluye también la acción `GetUser`, que es necesaria para ver la mayor parte de la información de la página **My security credentials** (Mis credenciales de seguridad).
+ La instrucción `AllowManageOwnAccessKeys` permite al usuario crear, actualizar y eliminar sus propias claves de acceso. El usuario también puede recuperar información acerca de cuándo se utilizó por última vez la clave de acceso especificada.
+ La instrucción `AllowManageOwnSigningCertificates` permite al usuario cargar, actualizar y eliminar sus propios certificados de firma.
+ La instrucción `AllowManageOwnSSHPublicKeys` permite al usuario cargar, actualizar y eliminar sus propias claves públicas SSH de CodeCommit.
+ La instrucción `AllowManageOwnGitCredentials` permite al usuario cargar, crear y eliminar sus propias credenciales de Git de CodeCommit.
Esta política no permite a los usuarios ver ni administrar sus propios dispositivos MFA. Tampoco pueden ver la página **Usuarios** de la consola de IAM ni utilizar esa página para obtener acceso a su propia información de usuario. Si desea permitirlo, añada la acción `iam:ListUsers` a la instrucción `AllowViewAccountInfo`. Tampoco permite a los usuarios cambiar su contraseña en su propia página de usuario. Si desea permitirlo, añada las acciones `iam:CreateLoginProfile`, `iam:DeleteLoginProfile`, `iam:GetLoginProfile` e `iam:UpdateLoginProfile` a la instrucción `AllowManageOwnPasswords`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowViewAccountInfo",
"Effect": "Allow",
"Action": [
"iam:GetAccountPasswordPolicy",
"iam:GetAccountSummary"
],
"Resource": "*"
},
{
"Sid": "AllowManageOwnPasswords",
"Effect": "Allow",
"Action": [
"iam:ChangePassword",
"iam:GetUser"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnAccessKeys",
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:DeleteAccessKey",
"iam:ListAccessKeys",
"iam:UpdateAccessKey",
"iam:GetAccessKeyLastUsed"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnSigningCertificates",
"Effect": "Allow",
"Action": [
"iam:DeleteSigningCertificate",
"iam:ListSigningCertificates",
"iam:UpdateSigningCertificate",
"iam:UploadSigningCertificate"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnSSHPublicKeys",
"Effect": "Allow",
"Action": [
"iam:DeleteSSHPublicKey",
"iam:GetSSHPublicKey",
"iam:ListSSHPublicKeys",
"iam:UpdateSSHPublicKey",
"iam:UploadSSHPublicKey"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnGitCredentials",
"Effect": "Allow",
"Action": [
"iam:CreateServiceSpecificCredential",
"iam:DeleteServiceSpecificCredential",
"iam:ListServiceSpecificCredentials",
"iam:ResetServiceSpecificCredential",
"iam:UpdateServiceSpecificCredential"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
}
]
}
```
------
# AWS: permite a los usuarios de IAM autenticados por MFA administrar su propio dispositivo MFA en la página Credenciales de seguridad
Este ejemplo muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM autenticados mediante [autenticación multifactor (MFA)](id_credentials_mfa.md) para administrar su propio dispositivo MFA en la página **Credenciales de seguridad**. En esta página de la Consola de administración de AWS se muestra información de la cuenta y del usuario, pero el usuario solo puede ver y editar su propio dispositivo MFA. Para permitir a los usuarios administrar todas sus credenciales con MFA, consulte [AWS: permite a los usuarios de IAM autenticados por MFA administrar sus propias credenciales en la página Credenciales de seguridad](reference_policies_examples_aws_my-sec-creds-self-manage.md).
**nota**
Si un usuario de IAM con esta política no está autenticado por MFA, esta política deniega el acceso a todas las acciones de AWS excepto las necesarias para autenticarse mediante MFA. Para utilizar la AWS CLI y la API de AWS, los usuarios de IAM primero deben recuperar su token de MFA mediante la operación [GetSessionToken](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetSessionToken.html) de AWS STS y, a continuación, utilizar dicho token para autenticar la operación deseada. Otras políticas, como las políticas basadas en recursos o identidad, pueden permitir acciones en otros servicios. Esta política denegará ese acceso si el usuario de IAM no se autentica mediante MFA.
Para información sobre el acceso a la página **Credenciales de seguridad**, consulte [Cómo cambian los usuarios de IAM su propia contraseña (consola)](id_credentials_passwords_user-change-own.md#ManagingUserPwdSelf-Console).
**¿Qué hace esta política? **
+ La instrucción `AllowViewAccountInfo` permite al usuario ver los detalles de un dispositivo MFA virtual que está habilitado para el usuario. Este permiso debe estar en su propia instrucción, ya que no es posible especificar el ARN de un recurso. En su lugar, debe especificar `"Resource" : "*"`.
+ La declaración `AllowManageOwnVirtualMFADevice` permite al usuario crear su propio dispositivo MFA virtual. El recurso de ARN de esta declaración permite al usuario crear un dispositivo MFA con cualquier nombre, pero las otras declaraciones en la política solo permiten al usuario adjuntar el dispositivo al usuario actualmente conectado.
+ La instrucción `AllowManageOwnUserMFA` permite al usuario ver o administrar su propio dispositivo MFA o U2F virtual o físico. El ARN de recurso de esta instrucción permite el acceso únicamente al propio usuario de IAM. Los usuarios no pueden ver ni administrar el dispositivo MFA de otros usuarios.
+ La instrucción `DenyAllExceptListedIfNoMFA` deniega el acceso a todas las acciones de todos los servicios de AWS, salvo algunas acciones indicadas, pero ***solo si*** el usuario no ha iniciado sesión con MFA. La instrucción utiliza una combinación de `"Deny"` y `"NotAction"` para denegar explícitamente el acceso a las acciones que no se indican en la lista. Esta instrucción no deniega ni permite los elementos enumerados. Son otras instrucciones de la política las que permiten las acciones. Para obtener más información acerca de la lógica de esta instrucción, consulte [NotAction con Deny](reference_policies_elements_notaction.md). Si el usuario ha iniciado sesión con MFA, la prueba `Condition` no se cumple y esta instrucción no deniega ninguna acción. En este caso, otras políticas o instrucciones determinan los permisos del usuario.
Esta instrucción garantiza que cuando el usuario no ha iniciado sesión con MFA únicamente pueda realizar las acciones que se muestran. Además, puede realizar las acciones mostradas solo si otra instrucción o política permite el acceso a estas acciones.
La versión `...IfExists` del operador `Bool` garantiza que si falta la clave `aws:MultiFactorAuthPresent`, la condición devuelve el valor verdadero. Esto significa que a un usuario que obtiene acceso a una operación de la API con credenciales a largo plazo, como una clave de acceso, se le deniega el acceso a las operaciones de la API que no son de IAM.
Esta política no permite a los usuarios ver la página **Usuarios** de la consola de IAM ni utilizar esa página para obtener acceso a su propia información de usuario. Para permitir esto, añada la acción `iam:ListUsers` a la instrucción `AllowViewAccountInfo` y a la instrucción `DenyAllExceptListedIfNoMFA`.
**aviso**
No agregue el permiso para eliminar un dispositivo MFA sin la autenticación MFA. Los usuarios con esta política es posible que intenten asignarse a sí mismos un dispositivo MFA virtual y reciban un error que indica que no están autorizados para realizar `iam:DeleteVirtualMFADevice`. Si esto ocurre, **no** agregue ese permiso a la declaración `DenyAllExceptListedIfNoMFA`. A los usuarios que no se han autenticado con MFA nunca se les debe permitir eliminar su dispositivo MFA. Los usuarios pueden ver este error si han empezado anteriormente la asignación de un dispositivo MFA virtual a su usuario y cancelado el proceso. Para solucionar este problema, usted u otro administrador debe eliminar el dispositivo MFA virtual existente del usuario con la AWS CLI o la API de AWS. Para obtener más información, consulte [No tengo autorización para realizar la operación iam:DeleteVirtualMFADevice](troubleshoot.md#troubleshoot_general_access-denied-delete-mfa).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowViewAccountInfo",
"Effect": "Allow",
"Action": "iam:ListVirtualMFADevices",
"Resource": "*"
},
{
"Sid": "AllowManageOwnVirtualMFADevice",
"Effect": "Allow",
"Action": [
"iam:CreateVirtualMFADevice"
],
"Resource": "arn:aws:iam::*:mfa/*"
},
{
"Sid": "AllowManageOwnUserMFA",
"Effect": "Allow",
"Action": [
"iam:DeactivateMFADevice",
"iam:EnableMFADevice",
"iam:GetUser",
"iam:GetMFADevice",
"iam:ListMFADevices",
"iam:ResyncMFADevice"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "DenyAllExceptListedIfNoMFA",
"Effect": "Deny",
"NotAction": [
"iam:CreateVirtualMFADevice",
"iam:EnableMFADevice",
"iam:GetUser",
"iam:ListMFADevices",
"iam:ListVirtualMFADevices",
"iam:ResyncMFADevice",
"sts:GetSessionToken"
],
"Resource": "*",
"Condition": {
"BoolIfExists": {"aws:MultiFactorAuthPresent": "false"}
}
}
]
}
```
------
# AWS: permite a los usuarios de IAM cambiar su propia contraseña de consola en la página Credenciales de seguridad
Este ejemplo muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM cambiar su propia contraseña de la Consola de administración de AWS en la página **Credenciales de seguridad**. En esta página de la Consola de administración de AWS se muestra información de la cuenta y del usuario, pero el usuario solo tiene acceso a su propia contraseña. Para permitir a los usuarios administrar todas sus credenciales con MFA, consulte [AWS: permite a los usuarios de IAM autenticados por MFA administrar sus propias credenciales en la página Credenciales de seguridad](reference_policies_examples_aws_my-sec-creds-self-manage.md). Para permitir a los usuarios administrar sus propias credenciales sin utilizar MFA, consulte [AWS: permite a los usuarios de IAM administrar sus propias credenciales en la página Credenciales de seguridad](reference_policies_examples_aws_my-sec-creds-self-manage-no-mfa.md).
Para información sobre el acceso a la página **Credenciales de seguridad**, consulte [Cómo cambian los usuarios de IAM su propia contraseña (consola)](id_credentials_passwords_user-change-own.md#ManagingUserPwdSelf-Console).
**Qué hace esta política? **
+ La instrucción `ViewAccountPasswordRequirements` permite al usuario ver los requisitos de contraseña de la cuenta y cambiar la contraseña de su propio usuario de IAM.
+ La instrucción `ChangeOwnPassword` permite al usuario cambiar su propia contraseña. Esta instrucción incluye también la acción `GetUser`, que es necesaria para ver la mayor parte de la información de la página **My security credentials** (Mis credenciales de seguridad).
Esta política no permite a los usuarios ver la página **Usuarios** de la consola de IAM ni utilizar esa página para obtener acceso a su propia información de usuario. Si desea permitirlo, añada la acción `iam:ListUsers` a la instrucción `ViewAccountPasswordRequirements`. Tampoco permite a los usuarios cambiar su contraseña en su propia página de usuario. Si desea permitirlo, agregue las acciones `iam:GetLoginProfile` e `iam:UpdateLoginProfile` a la instrucción `ChangeOwnPasswords`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ViewAccountPasswordRequirements",
"Effect": "Allow",
"Action": "iam:GetAccountPasswordPolicy",
"Resource": "*"
},
{
"Sid": "ChangeOwnPassword",
"Effect": "Allow",
"Action": [
"iam:GetUser",
"iam:ChangePassword"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
}
]
}
```
------
# AWS: permite a los usuarios de IAM administrar su propia contraseña, sus claves de acceso y sus claves públicas SSH en la página Credenciales de seguridad
Este ejemplo muestra cómo podría crear una política de IAM que permita a los usuarios de IAM administrar su propia contraseña, claves de acceso y certificados X.509 en la página **Credenciales de seguridad**. En esta página de la Consola de administración de AWS, se muestra información de la cuenta, como el ID de cuenta y el ID de usuario canónico. Los usuarios también pueden ver y editar sus propias contraseñas, claves de acceso, dispositivos MFA, certificados X.509, claves SSH y credenciales de Git. Esta política de ejemplo incluye los permisos que son necesarios únicamente para ver y editar la contraseña, las claves de acceso y el certificado X.509. Para permitir a los usuarios administrar todas sus credenciales con MFA, consulte [AWS: permite a los usuarios de IAM autenticados por MFA administrar sus propias credenciales en la página Credenciales de seguridad](reference_policies_examples_aws_my-sec-creds-self-manage.md). Para permitir a los usuarios administrar sus propias credenciales sin utilizar MFA, consulte [AWS: permite a los usuarios de IAM administrar sus propias credenciales en la página Credenciales de seguridad](reference_policies_examples_aws_my-sec-creds-self-manage-no-mfa.md).
Para información sobre el acceso a la página **Credenciales de seguridad**, consulte [Cómo cambian los usuarios de IAM su propia contraseña (consola)](id_credentials_passwords_user-change-own.md#ManagingUserPwdSelf-Console).
**Qué hace esta política? **
+ La instrucción `AllowViewAccountInfo` permite al usuario ver la información de nivel de cuenta. Estos permisos deben estar en su propia instrucción, ya que no admiten o no requieren un ARN de recurso. En lugar de ello, los permisos especifican `"Resource" : "*"`. Esta instrucción incluye las siguientes acciones que permiten al usuario ver información específica:
+ `GetAccountPasswordPolicy`: ver los requisitos de contraseña de la cuenta y cambiar la contraseña de su propio usuario de IAM.
+ `GetAccountSummary`: ver el ID de cuenta y el [ID de usuario canónico de la cuenta](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId).
+ La instrucción `AllowManageOwnPasswords` permite al usuario cambiar su propia contraseña. Esta instrucción incluye también la acción `GetUser`, que es necesaria para ver la mayor parte de la información de la página **My security credentials** (Mis credenciales de seguridad).
+ La instrucción `AllowManageOwnAccessKeys` permite al usuario crear, actualizar y eliminar sus propias claves de acceso. El usuario también puede recuperar información acerca de cuándo se utilizó por última vez la clave de acceso especificada.
+ La instrucción `AllowManageOwnSSHPublicKeys` permite al usuario cargar, actualizar y eliminar sus propias claves públicas SSH de CodeCommit.
Esta política no permite a los usuarios ver ni administrar sus propios dispositivos MFA. Tampoco pueden ver la página **Usuarios** de la consola de IAM ni utilizar esa página para obtener acceso a su propia información de usuario. Si desea permitirlo, añada la acción `iam:ListUsers` a la instrucción `AllowViewAccountInfo`. Tampoco permite a los usuarios cambiar su contraseña en su propia página de usuario. Si desea permitirlo, agregue las acciones `iam:GetLoginProfile` e `iam:UpdateLoginProfile` a la instrucción `AllowManageOwnPasswords`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowViewAccountInfo",
"Effect": "Allow",
"Action": [
"iam:GetAccountPasswordPolicy",
"iam:GetAccountSummary"
],
"Resource": "*"
},
{
"Sid": "AllowManageOwnPasswords",
"Effect": "Allow",
"Action": [
"iam:ChangePassword",
"iam:GetUser"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnAccessKeys",
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:DeleteAccessKey",
"iam:ListAccessKeys",
"iam:UpdateAccessKey",
"iam:GetAccessKeyLastUsed"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowManageOwnSSHPublicKeys",
"Effect": "Allow",
"Action": [
"iam:DeleteSSHPublicKey",
"iam:GetSSHPublicKey",
"iam:ListSSHPublicKeys",
"iam:UpdateSSHPublicKey",
"iam:UploadSSHPublicKey"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
}
]
}
```
------
# AWS: deniega el acceso a AWS en función de la región solicitada.
En este ejemplo se muestra cómo crear una política basada en identidad que deniegue el acceso a cualquier acción fuera de las regiones especificadas mediante la [clave de condición `aws:RequestedRegion`](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion), a excepción de las acciones en los servicios especificados al utilizar `NotAction`. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Esta política utiliza el elemento `NotAction` con el efecto `Deny`, que deniega explícitamente el acceso a todas las acciones que *no* figuran en la instrucción. Las acciones de los servicios CloudFront, IAM, Route 53 y Soporte no deben ser denegados porque son servicios globales populares de AWS con un único punto de enlace que se encuentra físicamente en la región `us-east-1`. Dado que todas las solicitudes a estos servicios se realizan a la región `us-east-1`, las solicitudes se denegaría sin el elemento `NotAction`. Edite este elemento para incluir acciones para otros servicios globales de AWS que utilice, como, por ejemplo, `budgets`, `globalaccelerator`, `importexport`, `organizations`, o `waf`. Algunos otros servicios globales, como Amazon Q Developer en aplicaciones de chat y AWS Device Farm, son servicios globales con puntos de conexión ubicados físicamente en la región `us-west-2`. Para obtener más información acerca de todos los servicios que tienen un único punto de enlace global, consulte [Regiones y puntos de enlace de AWS](https://docs.aws.amazon.com/general/latest/gr/rande.html) en la *Referencia general de AWS*. Para obtener más información acerca de cómo utilizar el elemento `NotAction` con el efecto `Deny`, consulte [Elementos de política JSON de IAM: NotAction](reference_policies_elements_notaction.md).
**importante**
Esta política no permite ninguna acción. Utilice esta política en combinación con otras políticas que permiten acciones específicas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyAllOutsideRequestedRegions",
"Effect": "Deny",
"NotAction": [
"cloudfront:*",
"iam:*",
"organizations:*",
"route53:*",
"support:*"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:RequestedRegion": [
"eu-central-1",
"eu-west-1",
"eu-west-2",
"eu-west-3"
]
}
}
}
]
}
```
------
# AWS: Deniega acceso a AWS en función de la dirección IP de origen
Este ejemplo muestra cómo puede crear una política basada en identidad que deniegue el acceso a todas las acciones de AWS en la cuenta cuando la solicitud proviene de *entidades principales* que están fuera del intervalo de direcciones IP especificadas. La política es útil cuando las direcciones IP de su empresa están dentro de los rangos especificados. En este ejemplo, la solicitud se deniega a menos que se origine en el rango de CIDR 192.0.2.0/24 o 203.0.113.0/24. La política no deniega las solicitudes realizadas por los servicios de AWS que utilizan [Sesiones de acceso directo](access_forward_access_sessions.md) mientras la dirección IP del solicitante original se conserva.
Tenga cuidado con el uso de condiciones negativas en la misma instrucción de política que `"Effect": "Deny"`. Cuando lo haga, las acciones especificadas en la instrucción de política se deniegan explícitamente en todas las condiciones *excepto* en las especificadas.
**importante**
Esta política no permite ninguna acción. Utilice esta política en combinación con otras políticas que permiten acciones específicas.
Cuando otras políticas permiten acciones, las entidades principales pueden realizar solicitudes desde dentro del intervalo de direcciones IP. Un servicio de AWS también puede realizar solicitudes utilizando las credenciales de la entidad principal. Cuando una entidad principal realiza una solicitud desde fuera del intervalo de direcciones IP, la solicitud se deniega.
Para obtener más información acerca del uso de las claves de condición `aws:SourceIp`, incluida información acerca de cuándo `aws:SourceIp` puede no funcionar en su política, consulte [Claves de contexto de condición globales de AWS](reference_policies_condition-keys.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Deny",
"Action": "*",
"Resource": "*",
"Condition": {
"NotIpAddress": {
"aws:SourceIp": [
"192.0.2.0/24",
"203.0.113.0/24"
]
}
}
}
}
```
------
# AWS: denegar el acceso a los recursos de Amazon S3 fuera de su cuenta, excepto AWS Data Exchange
El siguiente ejemplo muestra cómo crear una política basada en identidad que deniegue el acceso a todos los recursos de AWS que no pertenezcan a su cuenta, excepto los recursos que AWS Data Exchange requiere para un funcionamiento normal. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Puede crear una política similar para restringir el acceso a los recursos dentro de una organización o una unidad organizativa y, al mismo tiempo, contabilizar los recursos propios de AWS Data Exchange mediante las claves de condición `aws:ResourceOrgPaths` y `aws:ResourceOrgID`.
Si usa AWS Data Exchange en su entorno, el servicio crea recursos como los buckets de Amazon S3 que son propiedad de la cuenta de servicio e interactúa con ellos. Por ejemplo, AWS Data Exchange envía solicitudes a los buckets de Amazon S3 propiedad del servicio AWS Data Exchange en nombre de la entidad principal de IAM (usuario o rol) que invoca las API de AWS Data Exchange. En ese caso, el uso de `aws:ResourceAccount`, `aws:ResourceOrgPaths` o `aws:ResourceOrgID` en una política, sin tener en cuenta los recursos propiedad de AWS Data Exchange, deniega el acceso a los buckets propiedad de la cuenta de servicio.
+ La declaración, `DenyAllAwsResourcesOutsideAccountExceptS3`, utiliza el elemento `NotAction` con el efecto [Deny](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_effect.html) (Denegar) que deniega explícitamente el acceso a todas las acciones que no figuren en la declaración y que tampoco pertenezcan a la cuenta incluida en la lista. El elemento `NotAction` indica las excepciones a esta declaración. Estas acciones son la excepción a esta declaración porque, si las acciones se llevan a cabo en los recursos creados por AWS Data Exchange, la política las deniega.
+ La declaración, `DenyAllS3ResoucesOutsideAccountExceptDataExchange`, utiliza una combinación de las condiciones `ResourceAccount` y `CalledVia` para denegar el acceso a las tres acciones de Amazon S3 excluidas en la declaración anterior. La declaración deniega las acciones si los recursos no pertenecen a la cuenta enumerada y si el servicio de llamadas no es AWS Data Exchange. La declaración no deniega las acciones si el recurso pertenece a la cuenta enumerada o si la entidad principal de servicio enumerada, `dataexchange.amazonaws.com`, lleva a cabo las operaciones.
**importante**
Esta política no permite ninguna acción. Utiliza el efecto `Deny` que deniega el acceso a todos los recursos enumerados en la declaración que no pertenecen a la cuenta que se indica. Utilice esta política en combinación con otras políticas que permiten acceder a acciones específicas.
El siguiente ejemplo muestra cómo puede configurar la política para permitir el acceso a los buckets de Amazon S3 necesarios.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DenyAllAwsReourcesOutsideAccountExceptAmazonS3",
"Effect": "Deny",
"NotAction": [
"s3:GetObject",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:ResourceAccount": [
"111122223333"
]
}
}
},
{
"Sid": "DenyAllS3ResourcesOutsideAccountExceptDataExchange",
"Effect": "Deny",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:ResourceAccount": [
"111122223333"
]
},
"ForAllValues:StringNotEquals": {
"aws:CalledVia": [
"dataexchange.amazonaws.com"
]
}
}
}
]
}
```
------
# AWS Data Pipeline: deniega el acceso a canalizaciones DataPipeline que el usuario no ha creado
En este ejemplo se muestra cómo crear una política basada en identidad que deniegue el acceso a canalizaciones que el usuario no haya creado. Si el valor del campo `PipelineCreator` coincide con el nombre de usuario de IAM, no se denegarán las acciones especificadas. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS.
**importante**
Esta política no permite ninguna acción. Utilice esta política en combinación con otras políticas que permiten acciones específicas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExplicitDenyIfNotTheOwner",
"Effect": "Deny",
"Action": [
"datapipeline:ActivatePipeline",
"datapipeline:AddTags",
"datapipeline:DeactivatePipeline",
"datapipeline:DeletePipeline",
"datapipeline:DescribeObjects",
"datapipeline:EvaluateExpression",
"datapipeline:GetPipelineDefinition",
"datapipeline:PollForTask",
"datapipeline:PutPipelineDefinition",
"datapipeline:QueryObjects",
"datapipeline:RemoveTags",
"datapipeline:ReportTaskProgress",
"datapipeline:ReportTaskRunnerHeartbeat",
"datapipeline:SetStatus",
"datapipeline:SetTaskStatus",
"datapipeline:ValidatePipelineDefinition"
],
"Resource": ["*"],
"Condition": {
"StringNotEquals": {"datapipeline:PipelineCreator": "${aws:userid}"}
}
}
]
}
```
------
# Amazon DynamoDB: permite el acceso a una determinada tabla
En este ejemplo se muestra cómo crear una política basada en identidad que permita el acceso completo a la tabla `MyTable` de DynamoDB. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
**importante**
Esta política permite todas las acciones que pueden llevarse a cabo en una tabla de DynamoDB. Para revisar estas acciones, consulte [Permisos de la API de DynamoDB: referencia sobre acciones, recursos y condiciones](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/api-permissions-reference.html) en la *Guía para desarrolladores de Amazon DynamoDB*. Puede proporcionar los mismos permisos si enumera cada acción individual. Sin embargo, si utiliza el comodín (`*`) en el elemento `Action`, como `"dynamodb:List*"`, no tendrá que actualizar la política si DynamoDB agrega una nueva acción List.
Esta política solo permite realizar acciones en las tablas de DynamoDB que existen con el nombre especificado. Para permitir a los usuarios obtener acceso de `Read` a todos los elementos de DynamoDB, también puede asociar la política administrada por [AmazonDynamoDBReadOnlyAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonDynamoDBReadOnlyAccess) de AWS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ListAndDescribe",
"Effect": "Allow",
"Action": [
"dynamodb:List*",
"dynamodb:DescribeReservedCapacity*",
"dynamodb:DescribeLimits",
"dynamodb:DescribeTimeToLive"
],
"Resource": "*"
},
{
"Sid": "SpecificTable",
"Effect": "Allow",
"Action": [
"dynamodb:BatchGet*",
"dynamodb:DescribeStream",
"dynamodb:DescribeTable",
"dynamodb:Get*",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWrite*",
"dynamodb:CreateTable",
"dynamodb:Delete*",
"dynamodb:Update*",
"dynamodb:PutItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/MyTable"
}
]
}
```
------
# Amazon DynamoDB: permite el acceso a atributos específicos
En este ejemplo se muestra cómo crear una política basada en identidad que permita el acceso a los atributos específicos de DynamoDB. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
El requisito `dynamodb:Select` impide que la acción de la API devuelva cualquier atributo no permitido, como una proyección de índice. Para obtener más información sobre las claves de condición de DynamoDB, consulte [Especificación de condiciones: uso de claves de condiciones](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/specifying-conditions.html#FGAC_DDB.ConditionKeys) en la *Guía para desarrolladores de Amazon DynamoDB*. Para obtener información acerca de la utilización de varias condiciones o de varias claves de condición dentro del bloque `Condition` de una política de IAM, consulte [Múltiples valores en un elemento Condition](reference_policies_elements_condition.md#Condition-multiple-conditions).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:BatchGetItem",
"dynamodb:Query",
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:BatchWriteItem"
],
"Resource": ["arn:aws:dynamodb:*:*:table/table-name"],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:Attributes": [
"column-name-1",
"column-name-2",
"column-name-3"
]
},
"StringEqualsIfExists": {"dynamodb:Select": "SPECIFIC_ATTRIBUTES"}
}
}
]
}
```
------
# Amazon DynamoDB: permite el acceso en el nivel de elemento a DynamoDB en función de un ID de Amazon Cognito
En este ejemplo, se muestra cómo crear una política basada en identidad que permita el acceso de todo el elemento a la tabla de DynamoDB `MyTable` según el ID de usuario del grupo de identidades de Amazon Cognito. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Para utilizar esta política, debe estructurar la tabla de DynamoDB, de modo que el ID de usuario del grupo de identidades de Amazon Cognito sea la clave de partición. Para obtener más información, consulte [Crear una tabla](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.Basics.html#WorkingWithTables.Basics.CreateTable) en la *Guía para desarrolladores de Amazon DynamoDB*.
Para obtener más información sobre las claves de condición de DynamoDB, consulte [Especificación de condiciones: uso de claves de condiciones](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/specifying-conditions.html#FGAC_DDB.ConditionKeys) en la *Guía para desarrolladores de Amazon DynamoDB*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:UpdateItem"
],
"Resource": ["arn:aws:dynamodb:*:*:table/MyTable"],
"Condition": {
"ForAllValues:StringEquals": {
"dynamodb:LeadingKeys": ["${cognito-identity.amazonaws.com:sub}"]
}
}
}
]
}
```
------
# Amazon EC2: asociar volúmenes de Amazon EBS a instancias EC2 en función de las etiquetas, o bien desasociarlos
Este ejemplo muestra cómo puede crear una política basada en identidad que permite a los propietarios de volúmenes de EBS asociar o desasociar sus volúmenes definidos mediante la etiqueta `VolumeUser` a instancias de EC2 etiquetadas como instancias de desarrollo (`Department=Development`). Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Para obtener más información sobre la creación de políticas de IAM para controlar el acceso a los recursos de Amazon EC2, consulte [Control de acceso a recursos de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html) en la *Guía del usuario de Amazon EC2*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:AttachVolume",
"ec2:DetachVolume"
],
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"StringEquals": {"aws:ResourceTag/Department": "Development"}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:AttachVolume",
"ec2:DetachVolume"
],
"Resource": "arn:aws:ec2:*:*:volume/*",
"Condition": {
"StringEquals": {"aws:ResourceTag/VolumeUser": "${aws:username}"}
}
}
]
}
```
------
# Amazon EC2: permite lanzar instancias EC2 en una determinada subred, de forma programática y en la consola
En este ejemplo se muestra cómo crear una política basada en identidad que permita enumerar información de todos los objetos de EC2 y lanzar instancias de EC2 en una subred específica. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:Describe*",
"ec2:GetConsole*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "ec2:RunInstances",
"Resource": [
"arn:aws:ec2:*:*:subnet/subnet-subnet-id",
"arn:aws:ec2:*:*:network-interface/*",
"arn:aws:ec2:*:*:instance/*",
"arn:aws:ec2:*:*:volume/*",
"arn:aws:ec2:*::image/ami-*",
"arn:aws:ec2:*:*:key-pair/*",
"arn:aws:ec2:*:*:security-group/*"
]
}
]
}
```
------
# Amazon EC2: permite administrar grupos de seguridad de EC2 con un par de etiquetas de valor de clave específico, mediante programación y en la consola
En este ejemplo se muestra cómo crear una política basada en identidad que otorga a los usuarios permiso a fin de tomar ciertas acciones para grupos de seguridad que tienen la misma etiqueta. Esta política concede permisos para ver grupos de seguridad en la consola de Amazon EC2, así como para agregar y quitar reglas de entrada y salida y enumerar y modificar las descripciones de las reglas de los grupos de seguridad existentes que tengan la etiqueta `Department=Test`. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:DescribeSecurityGroups",
"ec2:DescribeSecurityGroupRules",
"ec2:DescribeTags"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:AuthorizeSecurityGroupIngress",
"ec2:RevokeSecurityGroupIngress",
"ec2:AuthorizeSecurityGroupEgress",
"ec2:RevokeSecurityGroupEgress",
"ec2:ModifySecurityGroupRules",
"ec2:UpdateSecurityGroupRuleDescriptionsIngress",
"ec2:UpdateSecurityGroupRuleDescriptionsEgress"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:security-group/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/Department": "Test"
}
}
},
{
"Effect": "Allow",
"Action": [
"ec2:ModifySecurityGroupRules"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:security-group-rule/*"
]
}
]
}
```
------
# Amazon EC2: permite iniciar o detener instancias EC2 que un usuario haya etiquetado, mediante programación y en la consola
En este ejemplo se muestra cómo crear una política basada en identidad que permita a un usuario de IAM iniciar o detener instancias de EC2, pero solo si la etiqueta `Owner` de la instancia tiene el valor del nombre de usuario de dicho usuario. Esta política define los permisos para el acceso programático y a la consola.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:StartInstances",
"ec2:StopInstances"
],
"Resource": "arn:aws:ec2:*:*:instance/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "${aws:username}"
}
}
},
{
"Effect": "Allow",
"Action": "ec2:DescribeInstances",
"Resource": "*"
}
]
}
```
------
# EC2: iniciar o detener instancias en función de las etiquetas
Este ejemplo muestra cómo podría crear una política basada en identidad que permita iniciar o detener instancias con el par de valor de clave de la etiqueta `Project = DataAnalytics`, pero solo por las entidades principales con el par de valor de clave de la etiqueta `Department = Data`. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
La condición de la política se cumple si ambas partes de la condición son ciertas. La instancia debe tener la etiqueta `Project=DataAnalytics`. Además, la entidad principal de IAM (usuario o rol) que realiza la solicitud debe tener la etiqueta `Department=Data`.
**nota**
Como práctica recomendada, asocie políticas con la clave de condición `aws:PrincipalTag` para grupos de IAM en el caso en el que algunos usuarios pudieran tener la etiqueta especificada y otros no.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "StartStopIfTags",
"Effect": "Allow",
"Action": [
"ec2:StartInstances",
"ec2:StopInstances"
],
"Resource": "arn:aws:ec2:us-east-1:123456789012:instance/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/Project": "DataAnalytics",
"aws:PrincipalTag/Department": "Data"
}
}
}
]
}
```
------
# EC2: iniciar o detener instancias basándose en etiquetas de recursos y principal coincidentes
Este ejemplo muestra cómo podría crear una política basada en identidad que permita a una entidad principal iniciar o detener una instancia de Amazon EC2 cuando la etiqueta de recurso de la instancia y la etiqueta de la entidad de seguridad tengan el mismo valor para la clave de etiqueta `CostCenter`. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
**nota**
Como práctica recomendada, asocie políticas con la clave de condición `aws:PrincipalTag` para grupos de IAM en el caso en el que algunos usuarios pudieran tener la etiqueta especificada y otros no.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"ec2:startInstances",
"ec2:stopInstances"
],
"Resource": "*",
"Condition": {"StringEquals":
{"aws:ResourceTag/CostCenter": "${aws:PrincipalTag/CostCenter}"}}
}
}
```
------
# Amazon EC2: permite el acceso completo a EC2 en una región determinada, mediante programación y en la consola
En este ejemplo se muestra cómo crear una política basada en identidad que permita el acceso completo a EC2 dentro de una región específica. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md). Para obtener una lista de códigos de región, consulte [Regiones disponibles](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-available-regions) en la *Guía del usuario de Amazon EC2*.
Como alternativa, puede utilizar la clave de condición global [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-requestedregion), que es admitida por todas las acciones de la API de Amazon EC2. Para obtener más información, consulte [Ejemplo: Limitar el acceso a una región específica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ExamplePolicies_EC2.html#iam-example-region) en la *Guía del usuario de Amazon EC2*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "ec2:*",
"Resource": "*",
"Effect": "Allow",
"Condition": {
"StringEquals": {
"ec2:Region": "us-east-2"
}
}
}
]
}
```
------
# Amazon EC2: permite iniciar o detener una instancia EC2 y modificar un grupo de seguridad mediante programación y en la consola
En este ejemplo se muestra cómo crear una política basada en identidad que permita iniciar o detener una determinada instancia de EC2 y modificar un grupo de seguridad específico. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeSecurityGroups",
"ec2:DescribeSecurityGroupReferences",
"ec2:DescribeStaleSecurityGroups"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"ec2:AuthorizeSecurityGroupEgress",
"ec2:AuthorizeSecurityGroupIngress",
"ec2:RevokeSecurityGroupEgress",
"ec2:RevokeSecurityGroupIngress",
"ec2:StartInstances",
"ec2:StopInstances"
],
"Resource": [
"arn:aws:ec2:*:*:instance/i-instance-id",
"arn:aws:ec2:*:*:security-group/sg-security-group-id"
],
"Effect": "Allow"
}
]
}
```
------
# Amazon EC2: requiere MFA (GetSessionToken) para operaciones EC2 específicas
En este ejemplo se muestra cómo crear una política basada en identidad que permita el acceso completo a todas las operaciones de API de AWS en Amazon EC2. Sin embargo, deniega de forma explícita el acceso a las operaciones de API `StopInstances` y `TerminateInstances` si el usuario no está autenticado mediante la [Multi-Factor Authentication (MFA)](id_credentials_mfa.md). Para hacer esto mediante programación, el usuario debe incluir los valores opcionales `SerialNumber` y `TokenCode` al llamar a la operación `GetSessionToken`. Esta operación devuelve las credenciales temporales que se hayan autenticado con MFA. Para obtener más información acerca del GetSessionToken, consulte [Solicitud de credenciales para usuarios de entornos que no son de confianza](id_credentials_temp_request.md#api_getsessiontoken).
¿Qué hace esta política?
+ La instrucción `AllowAllActionsForEC2` permite todas las acciones de Amazon EC2.
+ La declaración `DenyStopAndTerminateWhenMFAIsNotPresent` rechaza las acciones `StopInstances` y `TerminateInstances` cuando falta el contexto de MFA. Esto significa que las acciones se deniegan cuando falta el contexto de la autenticación multifactor (lo que indica que no se ha utilizado MFA). Una denegación anula el permiso.
**nota**
La verificación de la condición de `MultiFactorAuthPresent` en la instrucción `Deny` no debe ser `{"Bool":{"aws:MultiFactorAuthPresent":false}}` ya que dicha clave no está presente y no puede evaluarse cuando no se utiliza MFA. Por lo tanto, utilice la verificación `BoolIfExists` para ver si la clave está presente antes de comprobar el valor. Para obtener más información, consulte [Operadores de condición …IfExists](reference_policies_elements_condition_operators.md#Conditions_IfExists).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAllActionsForEC2",
"Effect": "Allow",
"Action": "ec2:*",
"Resource": "*"
},
{
"Sid": "DenyStopAndTerminateWhenMFAIsNotPresent",
"Effect": "Deny",
"Action": [
"ec2:StopInstances",
"ec2:TerminateInstances"
],
"Resource": "*",
"Condition": {
"BoolIfExists": {"aws:MultiFactorAuthPresent": false}
}
}
]
}
```
------
# Amazon EC2: limita el término de instancias EC2 en un rango de direcciones IP
Este ejemplo muestra cómo puede crear una política basada en identidad que limita instancias de EC2 al permitir la acción, pero denegar explícitamente el acceso cuando la solicitud procede de una dirección IP fuera del rango especificado. La política es útil cuando las direcciones IP de su empresa están dentro de los rangos especificados. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Si esta política se utiliza en combinación con otras políticas que permiten la acción `ec2:TerminateInstances` (como la política administrada por AWS [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)), se deniega el acceso. Esto se debe a que una instrucción de denegación explícita prevalece sobre las instrucciones de permiso. Para obtener más información, consulte [Cómo la lógica del código de aplicación de AWS evalúa las solicitudes para permitir o denegar el acceso](reference_policies_evaluation-logic_policy-eval-denyallow.md).
**importante**
La clave de condición `aws:SourceIp` deniega el acceso a un Servicio de AWS, como AWS CloudFormation, que realiza llamadas en su nombre. Para obtener más información sobre el uso de la clave de condición `aws:SourceIp`, consulte [Claves de contexto de condición globales de AWS](reference_policies_condition-keys.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["ec2:TerminateInstances"],
"Resource": ["*"]
},
{
"Effect": "Deny",
"Action": ["ec2:TerminateInstances"],
"Condition": {
"NotIpAddress": {
"aws:SourceIp": [
"192.0.2.0/24",
"203.0.113.0/24"
]
}
},
"Resource": ["*"]
}
]
}
```
------
# IAM: acceso a la API del simulador de políticas
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita utilizar la API del simulador de políticas para las políticas asociadas a un usuario, grupo o rol de la Cuenta de AWS actual. Esta política también permite el acceso para simular políticas menos sensibles transferidas a la API como cadenas. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"iam:GetContextKeysForCustomPolicy",
"iam:GetContextKeysForPrincipalPolicy",
"iam:SimulateCustomPolicy",
"iam:SimulatePrincipalPolicy"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
**nota**
Para permitir el acceso de un usuario a la consola del simulador de políticas para simular políticas asociadas a un usuario, grupo o rol en la Cuenta de AWS actual, consulte [IAM: permite el acceso a la consola del simulador de políticas](reference_policies_examples_iam_policy-sim-console.md).
# IAM: permite el acceso a la consola del simulador de políticas
Este ejemplo muestra cómo podría crear una política basada en identidad que permita utilizar la consola del simulador de políticas para las políticas asociadas a un usuario, grupo o rol de la Cuenta de AWS actual. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS.
Puede obtener acceso a la consola del simulador de políticas de IAM en: [https://policysim.aws.amazon.com/](https://policysim.aws.amazon.com/)
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"iam:GetGroup",
"iam:GetGroupPolicy",
"iam:GetPolicy",
"iam:GetPolicyVersion",
"iam:GetRole",
"iam:GetRolePolicy",
"iam:GetUser",
"iam:GetUserPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListAttachedRolePolicies",
"iam:ListAttachedUserPolicies",
"iam:ListGroups",
"iam:ListGroupPolicies",
"iam:ListGroupsForUser",
"iam:ListRolePolicies",
"iam:ListRoles",
"iam:ListUserPolicies",
"iam:ListUsers"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
# IAM: asumir funciones que tienen una etiqueta específica
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a un usuario de IAM asumir roles con el par de valor de clave de etiqueta `Project = ExampleCorpABC`. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Si una función con esta etiqueta existe en la misma cuenta que el usuario, este puede asumir esa función. Si una función con esta etiqueta existe en una cuenta que no sea la del usuario, requiere permisos adicionales. La política de confianza de la función entre cuentas también debe permitir al usuario o a todos los miembros de la cuenta del usuario para que asuman la función. Para obtener más información acerca de cómo utilizar las funciones para el acceso entre cuentas, consulte [Acceso para un usuario de IAM en otra Cuenta de AWS propia](id_roles_common-scenarios_aws-accounts.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AssumeTaggedRole",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "*",
"Condition": {
"StringEquals": {"iam:ResourceTag/Project": "ExampleCorpABC"}
}
}
]
}
```
------
# IAM: permite y deniega el acceso a varios servicios mediante programación y en la consola
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita acceso completo a varios servicios y acceso de autoadministración limitado en IAM. También deniega a los usuarios el acceso al bucket de `logs` de Amazon S3 o a la instancia de Amazon EC2 de `i-1234567890abcdef0` Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
**aviso**
Esta política permite acceso completo a cada acción y recurso en varios servicios. Esta política debe aplicarse únicamente a los administradores de confianza.
Puede utilizar esta política como límite de permisos para definir los permisos máximos que una política basada en identidad puede conceder a un usuario de IAM. Para obtener más información, consulte [Delegación de responsabilidades en otras personas mediante el uso de límites de permisos](access_policies_boundaries.md#access_policies_boundaries-delegate). Cuando la política se utiliza como un límite de permisos para un usuario, las declaraciones definen los siguientes límites:
+ La declaración `AllowServices` permite acceso completo a los servicios de AWS especificados. Esto significa que las acciones del usuario en estos servicios solamente están limitadas por las políticas de permisos que se han asociado al usuario.
+ La instrucción `AllowIAMConsoleForCredentials` permite el acceso para obtener una lista de todos los usuarios de IAM. Este acceso es necesario para recorrer la página **Users (Usuarios)** de la Consola de administración de AWS. También permite ver los requisitos de la contraseña de la cuenta, para que el usuario pueda cambiar su propia contraseña.
+ La instrucción `AllowManageOwnPasswordAndAccessKeys` permite a los usuarios administrar únicamente su propia contraseña de la consola y sus claves de acceso mediante programación. Esto es importante porque si otra política brinda al usuario acceso completo a IAM, este podría cambiar sus propios permisos o los de otros usuarios. Esta instrucción impide que eso ocurra.
+ La instrucción `DenyS3Logs` deniega explícitamente el acceso al bucket `logs`. Esta política aplica las restricciones de la empresa sobre el usuario.
+ La instrucción `DenyEC2Production` deniega explícitamente el acceso a la instancia `i-1234567890abcdef0`.
Esta política no permite el acceso a otros servicios o acciones. Cuando la política se utiliza como un límite de permisos en un usuario, aunque otras políticas asociadas al usuario permitan esas acciones, AWS deniega la solicitud.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowServices",
"Effect": "Allow",
"Action": [
"s3:*",
"cloudwatch:*",
"ec2:*"
],
"Resource": "*"
},
{
"Sid": "AllowIAMConsoleForCredentials",
"Effect": "Allow",
"Action": [
"iam:ListUsers",
"iam:GetAccountPasswordPolicy"
],
"Resource": "*"
},
{
"Sid": "AllowManageOwnPasswordAndAccessKeys",
"Effect": "Allow",
"Action": [
"iam:*AccessKey*",
"iam:ChangePassword",
"iam:GetUser",
"iam:*LoginProfile*"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "DenyS3Logs",
"Effect": "Deny",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::logs",
"arn:aws:s3:::logs/*"
]
},
{
"Sid": "DenyEC2Production",
"Effect": "Deny",
"Action": "ec2:*",
"Resource": "arn:aws:ec2:*:*:instance/i-1234567890abcdef0"
}
]
}
```
------
# IAM: agregar una etiqueta específica a un usuario con una etiqueta específica
Este ejemplo muestra cómo podría crear una política basada en identidad que permita agregar la clave de etiqueta `Department` con los valores de etiqueta `Marketing`, `Development` o `QualityAssurance` a un usuario de IAM. El usuario ya debe incluir el par clave-valor `JobFunction = manager`. Puede utilizar esta política para exigir que un administrador solo pertenezca a uno de tres departamentos. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
La instrucción `ListTagsForAllUsers` permite ver las etiquetas de todos los usuarios de la cuenta.
La primera condición de la instrucción `TagManagerWithSpecificDepartment` utiliza el operador de condición `StringEquals`. La condición se cumple si ambas partes de la condición son ciertas. El usuario que se etiqueta ya debe tener la etiqueta `JobFunction=Manager`. La solicitud debe incluir la clave de etiqueta `Department` con uno de los valores de etiqueta que se indican.
La segunda condición utiliza el operador de condición `ForAllValues:StringEquals`. La condición se cumple si todas las claves de etiqueta de la solicitud coinciden con la clave de la política. Esto significa que la única clave de etiqueta de la solicitud debe ser `Department`. Para obtener más información acerca del uso de `ForAllValues`, consulte [Operadores de conjunto para claves de contexto multivalor](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ListTagsForAllUsers",
"Effect": "Allow",
"Action": [
"iam:ListUserTags",
"iam:ListUsers"
],
"Resource": "*"
},
{
"Sid": "TagManagerWithSpecificDepartment",
"Effect": "Allow",
"Action": "iam:TagUser",
"Resource": "*",
"Condition": {"StringEquals": {
"iam:ResourceTag/JobFunction": "Manager",
"aws:RequestTag/Department": [
"Marketing",
"Development",
"QualityAssurance"
]
},
"ForAllValues:StringEquals": {"aws:TagKeys": "Department"}
}
}
]
}
```
------
# IAM: agregar una etiqueta específica con valores específicos
Este ejemplo muestra cómo podría crear una política basada en identidad que permita agregar solo la clave de la etiqueta `CostCenter` y el valor de la etiqueta `A-123` o el valor de la etiqueta `B-456` a cualquier rol o usuario de IAM. Puede utilizar esta política para limitar el etiquetado a una clave de etiqueta y un conjunto de valores de etiqueta específicos. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
La instrucción `ConsoleDisplay` permite ver las etiquetas de todos los usuarios y funciones de la cuenta.
La primera condición de la instrucción `AddTag` utiliza el operador de condición `StringEquals`. La condición se cumple si la solicitud incluye la clave de etiqueta `CostCenter` con uno de los valores de etiqueta que se indican.
La segunda condición utiliza el operador de condición `ForAllValues:StringEquals`. La condición se cumple si todas las claves de etiqueta de la solicitud coinciden con la clave de la política. Esto significa que la única clave de etiqueta de la solicitud debe ser `CostCenter`. Para obtener más información acerca del uso de `ForAllValues`, consulte [Operadores de conjunto para claves de contexto multivalor](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ConsoleDisplay",
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:GetUser",
"iam:ListRoles",
"iam:ListRoleTags",
"iam:ListUsers",
"iam:ListUserTags"
],
"Resource": "*"
},
{
"Sid": "AddTag",
"Effect": "Allow",
"Action": [
"iam:TagUser",
"iam:TagRole"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:RequestTag/CostCenter": [
"A-123",
"B-456"
]
},
"ForAllValues:StringEquals": {"aws:TagKeys": "CostCenter"}
}
}
]
}
```
------
# IAM: crear nuevos usuarios solo con etiquetas específicas
Este ejemplo muestra cómo podría crear una política basada en identidad que permita la creación de usuarios de IAM, pero solo con una o ambas claves de etiqueta `Department` y `JobFunction`. La clave de etiqueta `Department` debe tener el valor de etiqueta `Development` o `QualityAssurance`. La clave de etiqueta `JobFunction` debe tener el valor de etiqueta `Employee`. Puede utilizar esta política para exigir que los nuevos usuarios tengan una función de trabajo y un departamento específicos. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
La primera condición de la instrucción utiliza el operador de condición `StringEqualsIfExists`. Si hay una etiqueta con la clave `Department` o `JobFunction` en la solicitud, deberá tener el valor especificado. Si no hay ninguna clave, la evaluación considera que la condición se cumple. La única manera de la evaluación considere que la condición no se cumple es que una de las claves de condición especificadas se encuentre en la solicitud, pero con un valor distinto de los permitidos. Para obtener más información acerca del uso de `IfExists`, consulte [Operadores de condición …IfExists](reference_policies_elements_condition_operators.md#Conditions_IfExists).
La segunda condición utiliza el operador de condición `ForAllValues:StringEquals`. La condición se cumple si hay una coincidencia entre todas las claves de etiqueta especificadas en la solicitud con al menos uno de los valores de la política. Esto significa que todas las etiquetas de la solicitud deben encontrarse en esta lista. Sin embargo, la solicitud solo puede incluir una de las etiquetas de la lista. Por ejemplo, puede crear un usuario de IAM que solo tenga la etiqueta `Department=QualityAssurance`. Sin embargo, no puede crear un usuario de IAM con las etiquetas `JobFunction=employee` y `Project=core`. Para obtener más información acerca del uso de `ForAllValues`, consulte [Operadores de conjunto para claves de contexto multivalor](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "TagUsersWithOnlyTheseTags",
"Effect": "Allow",
"Action": [
"iam:CreateUser",
"iam:TagUser"
],
"Resource": "*",
"Condition": {
"StringEqualsIfExists": {
"aws:RequestTag/Department": [
"Development",
"QualityAssurance"
],
"aws:RequestTag/JobFunction": "Employee"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": [
"Department",
"JobFunction"
]
}
}
}
]
}
```
------
# IAM: generar y recuperar de informes de credenciales de IAM
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a los usuarios generar y descargar un informe que contenga una lista de todos los usuarios de IAM en su Cuenta de AWS. El informe muestra el estado de las credenciales del usuario, tales como las contraseñas, las claves de acceso, los dispositivos MFA y los certificados de firma. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS.
Para obtener más información sobre los informes de credenciales de , consulte [Generación de informes de credenciales para su Cuenta de AWS](id_credentials_getting-report.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"iam:GenerateCredentialReport",
"iam:GetCredentialReport"
],
"Resource": "*"
}
}
```
------
# IAM: permite administrar la pertenencia a un grupo mediante programación y en la consola
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita actualizar la pertenencia del grupo denominado `MarketingTeam`. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
¿Qué hace esta política?
+ La declaración `ViewGroups` permite que el usuario genere una lista de todos los usuarios y grupos en el Consola de administración de AWS. También permite al usuario ver información básica acerca de los usuarios de la cuenta. Estos permisos deben estar en su propia instrucción, ya que no admiten o no requieren un ARN de recurso. En lugar de ello, los permisos especifican `"Resource" : "*"`.
+ La declaración `ViewEditThisGroup` permite al usuario ver información sobre el grupo `MarketingTeam` y añadir y eliminar usuarios de ese grupo.
Esta política no permite al usuario ver o editar los permisos de los usuarios o el grupo `MarketingTeam`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ViewGroups",
"Effect": "Allow",
"Action": [
"iam:ListGroups",
"iam:ListUsers",
"iam:GetUser",
"iam:ListGroupsForUser"
],
"Resource": "*"
},
{
"Sid": "ViewEditThisGroup",
"Effect": "Allow",
"Action": [
"iam:AddUserToGroup",
"iam:RemoveUserFromGroup",
"iam:GetGroup"
],
"Resource": "arn:aws:iam::*:group/MarketingTeam"
}
]
}
```
------
# IAM: administrar una etiqueta específica
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita eliminar solo la etiqueta de IAM con la clave de etiqueta `Department` de las entidades (usuarios y roles). Esta política no limita el valor de la etiqueta `Department`. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"iam:TagUser",
"iam:TagRole",
"iam:UntagUser",
"iam:UntagRole"
],
"Resource": "*",
"Condition": {"ForAllValues:StringEquals": {"aws:TagKeys": "Department"}}
}
}
```
------
# IAM: pasar una función de IAM a un servicio de AWS específico
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita transferir cualquier rol de servicio de IAM al servicio de Amazon CloudWatch. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Una función de servicio es una función de IAM que especifica un servicio de AWS como la entidad principal que puede asumir la función. Esta permite que el servicio asuma la función y obtenga acceso a los recursos de otros servicios en su nombre. Para permitir que Amazon CloudWatch asuma el rol que esté pasando, debe especificar la entidad principal de servicio `cloudwatch.amazonaws.com` como la entidad principal de la política de confianza de su rol. El servicio define la entidad principal de servicio. Para conocer la entidad principal de un servicio, consulte la documentación correspondiente a dicho servicio. En algunos servicios, consulte [Servicios de AWS que funcionan con IAM](reference_aws-services-that-work-with-iam.md) y busque los servicios para los que se indique **Sí **en la columna **Roles vinculados a servicios**. Elija una opción **Sí** con un enlace para ver la documentación acerca del rol vinculado al servicio en cuestión. Busque `amazonaws.com` para ver el principal del servicio.
Para obtener más información acerca de cómo pasar una función de servicio a un servicio, consulte [Conceder permisos a un usuario para transferir un rol a un servicio de AWS](id_roles_use_passrole.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "*",
"Condition": {
"StringEquals": {"iam:PassedToService": "cloudwatch.amazonaws.com"}
}
}
]
}
```
------
# IAM: permite acceso de solo lectura a la consola de IAM sin informes
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM hacer cualquier acción de IAM que comience con la cadena `Get` o `List`. A medida que los usuarios trabajan con la consola, esta realiza solicitudes a IAM para obtener listas de grupos, usuarios, funciones y políticas, y para generar informes sobre esos recursos.
El asterisco actúa como un carácter comodín. Si utiliza `iam:Get*` en una política, los permisos resultantes incluyen todas las acciones de IAM que comienzan con `Get`, por ejemplo, `GetUser` y `GetRole`. Los comodines son útiles si se añaden nuevos tipos de entidades a IAM en el futuro. En ese caso, los permisos concedidos por la política permiten automáticamente a los usuarios generar listas y obtener los detalles acerca de esas nuevas entidades.
Esta política no se puede utilizar para generar informes o detalles de servicio al que se ha accedido por última vez. Para obtener una política diferente que lo permita, consulte [IAM: ermite el acceso de solo lectura a la consola de IAM](reference_policies_examples_iam_read-only-console.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"iam:Get*",
"iam:List*"
],
"Resource": "*"
}
}
```
------
# IAM: ermite el acceso de solo lectura a la consola de IAM
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM hacer cualquier acción de IAM que comience con la cadena `Get`, `List`, o `Generate`. A medida que los usuarios trabajan con la consola, esta realiza solicitudes a IAM para obtener listas de grupos, usuarios, funciones y políticas, y para generar informes sobre esos recursos.
El asterisco actúa como un carácter comodín. Si utiliza `iam:Get*` en una política, los permisos resultantes incluyen todas las acciones de IAM que comienzan con `Get`, por ejemplo, `GetUser` y `GetRole`. Utilizar un comodín resulta beneficioso, especialmente si se añaden nuevos tipos de entidades a IAM en el futuro. En ese caso, los permisos concedidos por la política permiten automáticamente a los usuarios generar listas y obtener los detalles acerca de esas nuevas entidades.
Utilice esta política para el acceso a la consola que incluye permisos para generar informes o detalles de servicio al que se accede por última vez. Para obtener una política diferente que no permite generar acciones, consulte [IAM: permite acceso de solo lectura a la consola de IAM sin informes](reference_policies_examples_iam_read-only-console-no-reporting.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"iam:Get*",
"iam:List*",
"iam:Generate*"
],
"Resource": "*"
}
}
```
------
# IAM: permite que usuarios específicos de IAM administren un grupo, mediante programación y en la consola
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a usuarios de IAM específicos administrar el grupo `AllUsers`. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
¿Qué hace esta política?
+ La declaración `AllowAllUsersToListAllGroups` permite generar listas de todos los grupos. Esto es necesario para acceder a la consola. Este permiso debe estar en su propia declaración, ya que no admite el ARN de un recurso. En lugar de ello, los permisos especifican `"Resource" : "*"`.
+ La declaración `AllowAllUsersToViewAndManageThisGroup` permite que se realicen todas las acciones de grupo que pueden ejecutarse en el tipo de recurso de grupo. No permite la acción `ListGroupsForUser`, que puede llevarse a cabo en un tipo de recurso de usuario y no en un tipo de recurso de grupo. Para obtener más información acerca de los tipos de recurso que puede especificar para una acción de IAM, consulte [Claves de acciones, recursos y condición de AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_identityandaccessmanagement.html#identityandaccessmanagement-actions-as-permissions).
+ La declaración `LimitGroupManagementAccessToSpecificUsers` deniega a los usuarios con los nombres especificados el acceso a escribir y las acciones de grupo de administración de permisos. Cuando un usuario especificado en la política intenta realizar cambios en el grupo, esta declaración no deniega la solicitud. Esta solicitud la permite la declaración `AllowAllUsersToViewAndManageThisGroup`. Si otros usuarios intentan realizar estas operaciones, se deniega la solicitud. Puede ver las acciones de IAM que se definen con los niveles de acceso de **Escritura** o **Administración de permisos** mientras crea esta política en la consola de IAM. Para ello, cambie de la pestaña **JSON** a la pestaña **Visual editor (Editor visual)**. Para obtener más información acerca de los niveles de acceso, consulte [Claves de condición, recursos y acciones de AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_identityandaccessmanagement.html#identityandaccessmanagement-actions-as-permissions).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAllUsersToListAllGroups",
"Effect": "Allow",
"Action": "iam:ListGroups",
"Resource": "*"
},
{
"Sid": "AllowAllUsersToViewAndManageThisGroup",
"Effect": "Allow",
"Action": "iam:*Group*",
"Resource": "arn:aws:iam::*:group/AllUsers"
},
{
"Sid": "LimitGroupManagementAccessToSpecificUsers",
"Effect": "Deny",
"Action": [
"iam:AddUserToGroup",
"iam:CreateGroup",
"iam:RemoveUserFromGroup",
"iam:DeleteGroup",
"iam:AttachGroupPolicy",
"iam:UpdateGroup",
"iam:DetachGroupPolicy",
"iam:DeleteGroupPolicy",
"iam:PutGroupPolicy"
],
"Resource": "arn:aws:iam::*:group/AllUsers",
"Condition": {
"StringNotEquals": {
"aws:username": [
"srodriguez",
"mjackson",
"adesai"
]
}
}
}
]
}
```
------
# IAM: permite establecer los requisitos de contraseña de la cuenta, mediante programación y en la consola
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a un usuario ver y actualizar los requisitos de contraseña de su cuenta. Los requisitos de contraseña especifican los requisitos de complejidad y periodos de rotación obligatorios para las contraseñas de los miembros de la cuenta. Esta política define los permisos para el acceso programático y a la consola.
Para obtener información sobre cómo configurar la política de requisitos de contraseñas para su cuenta, consulte [Configuración de una política de contraseñas de la cuenta para usuarios de IAM](id_credentials_passwords_account-policy.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"iam:GetAccountPasswordPolicy",
"iam:UpdateAccountPasswordPolicy"
],
"Resource": "*"
}
}
```
------
# IAM: obtiene acceso a la API del simulador de políticas en función de la ruta de acceso del usuario
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita utilizar la API del simulador de políticas únicamente a aquellos usuarios que tengan la ruta `Department/Development`. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"iam:GetContextKeysForPrincipalPolicy",
"iam:SimulatePrincipalPolicy"
],
"Effect": "Allow",
"Resource": "arn:aws:iam::*:user/Department/Development/*"
}
]
}
```
------
**nota**
Para crear una política que permita utilizar la consola del simulador de políticas a aquellos usuarios que tengan la ruta `Department/Development`, consulte [IAM: permite el acceso a la consola de simulador de políticas en función de la ruta de acceso del usuario](reference_policies_examples_iam_policy-sim-path-console.md).
# IAM: permite el acceso a la consola de simulador de políticas en función de la ruta de acceso del usuario
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita utilizar la consola del simulador de políticas únicamente a aquellos usuarios que tengan la ruta `Department/Development`. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Puede obtener acceso a la consola del simulador de políticas de IAM en: [https://policysim.aws.amazon.com/](https://policysim.aws.amazon.com/)
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"iam:GetPolicy",
"iam:GetUserPolicy"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Action": [
"iam:GetUser",
"iam:ListAttachedUserPolicies",
"iam:ListGroupsForUser",
"iam:ListUserPolicies",
"iam:ListUsers"
],
"Effect": "Allow",
"Resource": "arn:aws:iam::*:user/Department/Development/*"
}
]
}
```
------
# IAM: permite a los usuarios de IAM administrar ellos mismos un dispositivo MFA
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM administrar automáticamente su dispositivo de [autenticación multifactor (MFA)](id_credentials_mfa.md). Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS.
**nota**
Si un usuario de IAM con esta política no está autenticado por MFA, esta política deniega el acceso a todas las acciones de AWS excepto las necesarias para autenticarse mediante MFA. Si añade estos permisos a un usuario que haya iniciado sesión en AWS, es posible que tenga que cerrar sesión y volver a iniciarla para ver estos cambios.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowListActions",
"Effect": "Allow",
"Action": [
"iam:ListUsers",
"iam:ListVirtualMFADevices"
],
"Resource": "*"
},
{
"Sid": "AllowUserToCreateVirtualMFADevice",
"Effect": "Allow",
"Action": [
"iam:CreateVirtualMFADevice"
],
"Resource": "arn:aws:iam::*:mfa/*"
},
{
"Sid": "AllowUserToManageTheirOwnMFA",
"Effect": "Allow",
"Action": [
"iam:EnableMFADevice",
"iam:GetMFADevice",
"iam:ListMFADevices",
"iam:ResyncMFADevice"
],
"Resource": "arn:aws:iam::*:user/${aws:username}"
},
{
"Sid": "AllowUserToDeactivateTheirOwnMFAOnlyWhenUsingMFA",
"Effect": "Allow",
"Action": [
"iam:DeactivateMFADevice"
],
"Resource": [
"arn:aws:iam::*:user/${aws:username}"
],
"Condition": {
"Bool": {
"aws:MultiFactorAuthPresent": "true"
}
}
},
{
"Sid": "BlockMostAccessUnlessSignedInWithMFA",
"Effect": "Deny",
"NotAction": [
"iam:CreateVirtualMFADevice",
"iam:EnableMFADevice",
"iam:ListMFADevices",
"iam:ListUsers",
"iam:ListVirtualMFADevices",
"iam:ResyncMFADevice"
],
"Resource": "*",
"Condition": {
"BoolIfExists": {
"aws:MultiFactorAuthPresent": "false"
}
}
}
]
}
```
------
# IAM: permite a los usuarios de IAM actualizar sus propias credenciales mediante programación en la consola
En este ejemplo, se muestra cómo podría crear una política basada en identidad que les permita a los usuarios de IAM actualizar sus propias claves de acceso, certificados de firma, credenciales específicas de servicio y contraseñas. Esta política define los permisos para el acceso programático y a la consola.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:ListUsers",
"iam:GetAccountPasswordPolicy"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:*AccessKey*",
"iam:ChangePassword",
"iam:GetUser",
"iam:*ServiceSpecificCredential*",
"iam:*SigningCertificate*"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
}
]
}
```
------
Para descubrir cómo un usuario puede cambiar su propia contraseña en la consola, consulte [Cómo un usuario de IAM cambia su propia contraseña](id_credentials_passwords_user-change-own.md).
# IAM: visualización de la información de acceso reciente al servicio para una política de AWS Organizations
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita visualizar la información de acceso reciente al servicio para una determinada política de AWS Organizations. Esta política permite recuperar datos para la política de control de servicios (SCP) con el ID `p-policy123`. La persona que genera y ve el informe debe autenticarse con credenciales de cuenta de administración de AWS Organizations. Esta política permite al solicitante recuperar los datos de cualquier entidad de AWS Organizations en su organización. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Para obtener información importante sobre la información de acceso reciente, como los permisos necesarios, la solución de problemas y las regiones admitidas, consulte [Ajuste de permisos en AWS con información sobre los últimos accesos](access_policies_last-accessed.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowOrgsReadOnlyAndIamGetReport",
"Effect": "Allow",
"Action": [
"iam:GetOrganizationsAccessReport",
"organizations:Describe*",
"organizations:List*"
],
"Resource": "*"
},
{
"Sid": "AllowGenerateReportOnlyForThePolicy",
"Effect": "Allow",
"Action": "iam:GenerateOrganizationsAccessReport",
"Resource": "*",
"Condition": {
"StringEquals": {"iam:OrganizationsPolicyId": "p-policy123"}
}
}
]
}
```
------
# IAM: limita las políticas administradas que pueden aplicarse a un usuario, grupo o rol de
En este ejemplo se muestra cómo podría crear una política basada en identidad que limite la administración del cliente y las políticas administradas de AWS que pueden aplicarse a un rol, grupo o usuario de IAM. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"iam:AttachUserPolicy",
"iam:DetachUserPolicy"
],
"Resource": "*",
"Condition": {
"ArnEquals": {
"iam:PolicyARN": [
"arn:aws:iam::*:policy/policy-name-1",
"arn:aws:iam::*:policy/policy-name-2"
]
}
}
}
}
```
------
# AWS: denegar el acceso a recursos que están fuera de su cuenta, excepto a las políticas de IAM administradas por AWS
El uso de `aws:ResourceAccount` en sus políticas basadas en identidad puede afectar al usuario o a la capacidad del rol para utilizar algunos servicios que requieren la interacción con los recursos de las cuentas que son propiedad de un servicio.
Puede crear una política con una excepción para permitir la política de IAM administrada por AWS. Una cuenta administrada por un servicio fuera de AWS Organizations es propietaria de las políticas de IAM administradas. Hay cuatro acciones de IAM que enumeran y recuperan las políticas administradas por AWS. Utilice estas acciones en el elemento [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notaction.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_notaction.html) de la declaración. `AllowAccessToS3ResourcesInSpecificAccountsAndSpecificService1` en la política.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToResourcesInSpecificAccountsAndSpecificService1",
"Effect": "Deny",
"NotAction": [
"iam:GetPolicy",
"iam:GetPolicyVersion",
"iam:ListEntitiesForPolicy",
"iam:ListPolicies"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"aws:ResourceAccount": [
"111122223333"
]
}
}
}
]
}
```
------
# AWS Lambda: permite que una función Lambda acceda a una tabla de Amazon DynamoDB
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita el acceso de escritura y lectura a una tabla de Amazon DynamoDB específica. La política también permite escribir en archivos de registro en CloudWatch Logs. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Para utilizar esta política, adjunte la política a una [función de servicio](id_roles_create_for-service.md) de Lambda. Una función de servicio es una función que usted crea en su cuenta para permitir que un servicio realice acciones en su nombre. Esta función de servicio debe incluir AWS Lambda como la entidad principal en la política de confianza. Para obtener más información acerca de cómo utilizar esta política, consulte [Cómo crear una política de IAM AWS para conceder acceso AWS Lambda a una tabla de Amazon DynamoDB](https://aws.amazon.com/blogs/security/how-to-create-an-aws-iam-policy-to-grant-aws-lambda-access-to-an-amazon-dynamodb-table/) en Security Blog AWS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ReadWriteTable",
"Effect": "Allow",
"Action": [
"dynamodb:BatchGetItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem",
"dynamodb:PutItem",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:*:*:table/SampleTable"
},
{
"Sid": "GetStreamRecords",
"Effect": "Allow",
"Action": "dynamodb:GetRecords",
"Resource": "arn:aws:dynamodb:*:*:table/SampleTable/stream/* "
},
{
"Sid": "WriteLogStreamsAndGroups",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "*"
},
{
"Sid": "CreateLogGroup",
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "*"
}
]
}
```
------
# Amazon RDS: permite el acceso completo a la base de datos de RDS dentro de una región específica
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita el acceso completo a la base de datos de RDS dentro de una región específica. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "rds:*",
"Resource": ["arn:aws:rds:us-east-1:*:*"]
},
{
"Effect": "Allow",
"Action": ["rds:Describe*"],
"Resource": ["*"]
}
]
}
```
------
# Amazon RDS: permite restaurar bases de datos de RDS, mediante programación y en la consola
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita restaurar las bases de datos de RDS. Esta política define los permisos para el acceso programático y a la consola.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:Describe*",
"rds:CreateDBParameterGroup",
"rds:CreateDBSnapshot",
"rds:DeleteDBSnapshot",
"rds:Describe*",
"rds:DownloadDBLogFilePortion",
"rds:List*",
"rds:ModifyDBInstance",
"rds:ModifyDBParameterGroup",
"rds:ModifyOptionGroup",
"rds:RebootDBInstance",
"rds:RestoreDBInstanceFromDBSnapshot",
"rds:RestoreDBInstanceToPointInTime"
],
"Resource": "*"
}
]
}
```
------
# Amazon RDS: permite a los propietarios de etiquetas el acceso completo a los recursos de RDS que han etiquetado
Este ejemplo muestra cómo podría crear una política basada en identidad que permita a los propietarios de las etiquetas obtener acceso completo a los recursos de RDS que tengan etiquetados. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"rds:Describe*",
"rds:List*"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Action": [
"rds:DeleteDBInstance",
"rds:RebootDBInstance",
"rds:ModifyDBInstance"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {"rds:db-tag/Owner": "${aws:username}"}
}
},
{
"Action": [
"rds:ModifyOptionGroup",
"rds:DeleteOptionGroup"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {"rds:og-tag/Owner": "${aws:username}"}
}
},
{
"Action": [
"rds:ModifyDBParameterGroup",
"rds:ResetDBParameterGroup"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {"rds:pg-tag/Owner": "${aws:username}"}
}
},
{
"Action": [
"rds:AuthorizeDBSecurityGroupIngress",
"rds:RevokeDBSecurityGroupIngress",
"rds:DeleteDBSecurityGroup"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {"rds:secgrp-tag/Owner": "${aws:username}"}
}
},
{
"Action": [
"rds:DeleteDBSnapshot",
"rds:RestoreDBInstanceFromDBSnapshot"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {"rds:snapshot-tag/Owner": "${aws:username}"}
}
},
{
"Action": [
"rds:ModifyDBSubnetGroup",
"rds:DeleteDBSubnetGroup"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {"rds:subgrp-tag/Owner": "${aws:username}"}
}
},
{
"Action": [
"rds:ModifyEventSubscription",
"rds:AddSourceIdentifierToSubscription",
"rds:RemoveSourceIdentifierFromSubscription",
"rds:DeleteEventSubscription"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEqualsIgnoreCase": {"rds:es-tag/Owner": "${aws:username}"}
}
}
]
}
```
------
# Amazon S3: permite a los usuarios de Amazon Cognito obtener acceso a los objetos de su bucket
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a los usuarios de Amazon Cognito acceder a objetos de un bucket de Amazon S3 específico. Esta política permite el acceso únicamente a los objetos cuyo nombre incluya `cognito`, el nombre de la aplicación y el ID de la entidad principal federada, representados por la variable \$1\$1cognito-identity.amazonaws.com:sub\$1. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
**nota**
El valor “sub” utilizado en la clave de objeto no es el subvalor del usuario en el grupo de usuarios. Se trata del ID de identidad asociado al usuario en el grupo de identidades.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ListYourObjects",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": [
"arn:aws:s3:::bucket-name"
],
"Condition": {
"StringLike": {
"s3:prefix": [
"cognito/application-name/${cognito-identity.amazonaws.com:sub}/*"
]
}
}
},
{
"Sid": "ReadWriteDeleteYourObjects",
"Effect": "Allow",
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::bucket-name/cognito/application-name/${cognito-identity.amazonaws.com:sub}/*"
]
}
]
}
```
------
Amazon Cognito ofrece autenticación, autorización y administración de usuarios para sus aplicaciones móviles y web. Los usuarios pueden iniciar sesión directamente con un nombre de usuario y una contraseña o a través de un tercero como Facebook, Amazon o Google.
Los dos componentes principales de Amazon Cognito son los grupos de usuarios y los grupos de identidades. Los grupos de usuarios son directorios de usuarios que proporcionan a los usuarios de las aplicaciones opciones para inscribirse e iniciar sesión. Los grupos de identidades permiten conceder a los usuarios acceso a otros servicios de AWS. Puede utilizar los grupos de identidades y los grupos de usuarios juntos o por separado.
Para obtener más información sobre Amazon Cognito, consulte la [Guía del usuario de Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html).
# Amazon S3: permite a los usuarios federados obtener acceso a su directorio principal de Amazon S3, mediante programación y en la consola
Este ejemplo muestra cómo podría crear una política basada en identidades que permita a las entidades principales federadas acceder a su propio objeto de directorio principal en un bucket de S3. El directorio principal es un bucket que contiene una carpeta `home` y carpetas para entidades principales federadas individuales. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
La variable `${aws:userid}` de esta política se resuelve como `role-id:specified-name`. La parte `role-id` del ID de la entidad principal federada es un identificador único asignado al rol de la entidad principal federada durante su creación. Para obtener más información, consulte [Identificadores únicos](reference_identifiers.md#identifiers-unique-ids). El `specified-name` es el [parámetro RoleSessionName](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html#API_AssumeRoleWithWebIdentity_RequestParameters) transferido en la solicitud `AssumeRoleWithWebIdentity` cuando la entidad principal federada asumió su rol.
Puede ver el ID de rol con el comando AWS CLI de la `aws iam get-role --role-name specified-name`. Por ejemplo, imagine que especifica el nombre fácil de recordar `John` y que la CLI devuelve el ID de rol `AROAXXT2NJT7D3SIQN7Z6`. En este caso, el ID de usuario de la entidad principal federada es `AROAXXT2NJT7D3SIQN7Z6:John`. Esta política permite entonces que la entidad principal federada John acceda al bucket de Amazon S3 con el prefijo `AROAXXT2NJT7D3SIQN7Z6:John`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3ConsoleAccess",
"Effect": "Allow",
"Action": [
"s3:GetAccountPublicAccessBlock",
"s3:GetBucketAcl",
"s3:GetBucketLocation",
"s3:GetBucketPolicyStatus",
"s3:GetBucketPublicAccessBlock",
"s3:ListAccessPoints",
"s3:ListAllMyBuckets"
],
"Resource": "*"
},
{
"Sid": "ListObjectsInBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringLike": {
"s3:prefix": [
"",
"home/",
"home/${aws:userid}/*"
]
}
}
},
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:userid}",
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:userid}/*"
]
}
]
}
```
------
# Amazon S3: acceso al bucket de S3, pero bucket de producción denegado sin MFA reciente
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a un administrador de Amazon S3 obtener acceso a cualquier bucket, incluida la actualización, incorporación y eliminación de objetos. Sin embargo, deniega explícitamente el acceso al bucket de `amzn-s3-demo-bucket-production` si el usuario no ha iniciado sesión con la [autenticación multifactor (MFA)](id_credentials_mfa.md) en los últimos treinta minutos. Esta política concede los permisos necesarios para realizar esta acción en la consola o mediante programación a través de la AWS CLI o la API de AWS. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Esta política nunca permite acceso mediante programación al bucket `amzn-s3-demo-bucket` con claves de acceso de usuario a largo plazo. Esto se logra con la clave de condición `aws:MultiFactorAuthAge` con el operador de condición `NumericGreaterThanIfExists`. Esta condición de la política devuelve `true` si el MFA no está presente o si la edad del MFA es superior a 30 minutos. En esas situaciones, se deniega el acceso. Para acceder al bucket `amzn-s3-demo-bucket-production` mediante programación, el administrador de S3 debe utilizar credenciales temporales que se generaron en los últimos 30 minutos mediante la operación de API [GetSessionToken](id_credentials_temp_request.md#api_getsessiontoken).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ListAllS3Buckets",
"Effect": "Allow",
"Action": ["s3:ListAllMyBuckets"],
"Resource": "arn:aws:s3:::*"
},
{
"Sid": "AllowBucketLevelActions",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::*"
},
{
"Sid": "AllowBucketObjectActions",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:GetObject",
"s3:GetObjectAcl",
"s3:DeleteObject"
],
"Resource": "arn:aws:s3:::*/*"
},
{
"Sid": "RequireMFAForProductionBucket",
"Effect": "Deny",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket-production/*",
"arn:aws:s3:::amzn-s3-demo-bucket-production"
],
"Condition": {
"NumericGreaterThanIfExists": {"aws:MultiFactorAuthAge": "1800"}
}
}
]
}
```
------
# Amazon S3: permite a los usuarios de IAM obtener acceso a su directorio principal de S3, mediante programación y en la consola.
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a los usuarios de IAM obtener acceso a su propio objeto de bucket de directorio principal en S3. El directorio principal es un bucket que incluye una carpeta `home` y carpetas para usuarios individuales. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Esta política no funcionará cuando se utilicen los roles de IAM porque la variable `aws:username` no está disponible cuando se usan los roles de IAM. Para obtener información acerca de los valores de clave principales, consulte [Valores clave principales](reference_policies_variables.md#principaltable).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3ConsoleAccess",
"Effect": "Allow",
"Action": [
"s3:GetAccountPublicAccessBlock",
"s3:GetBucketAcl",
"s3:GetBucketLocation",
"s3:GetBucketPolicyStatus",
"s3:GetBucketPublicAccessBlock",
"s3:ListAccessPoints",
"s3:ListAllMyBuckets"
],
"Resource": "*"
},
{
"Sid": "ListObjectsInBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
"Condition": {
"StringLike": {
"s3:prefix": [
"",
"home/",
"home/${aws:username}/*"
]
}
}
},
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}",
"arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}/*"
]
}
]
}
```
------
# Amazon S3: restringir la administración a un bucket de S3 específico
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita restringir la administración de un bucket de Amazon S3 a ese bucket específico. Esta política concede permiso para llevar a cabo todas las acciones de Amazon S3, pero deniega el acceso a cada Servicio de AWS, excepto Amazon S3. Consulte el siguiente ejemplo. De acuerdo con esta política, solo puede acceder a las acciones de Amazon S3 que pueda hacer en un bucket de S3 o un recurso de objeto de S3. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
Si esta política se utiliza en combinación con otras políticas (como las políticas administradas por [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess) o [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess) de AWS) que permiten acciones denegadas por esta política, el acceso se denegará. Esto se debe a que una instrucción de denegación explícita prevalece sobre las instrucciones de permiso. Para obtener más información, consulte [Cómo la lógica del código de aplicación de AWS evalúa las solicitudes para permitir o denegar el acceso](reference_policies_evaluation-logic_policy-eval-denyallow.md).
**aviso**
[`NotAction`](reference_policies_elements_notaction.md) y [`NotResource`](reference_policies_elements_notresource.md) son elementos avanzados de política que deben utilizarse con precaución. Esta política deniega el acceso a cada servicio de AWS, salvo en Amazon S3. Si asocia esta política a un usuario, cualquier otra política que conceda permisos a otros servicios se pasará por alto y el acceso se denegará.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::bucket-name",
"arn:aws:s3:::bucket-name/*"
]
},
{
"Effect": "Deny",
"NotAction": "s3:*",
"NotResource": [
"arn:aws:s3:::bucket-name",
"arn:aws:s3:::bucket-name/*"
]
}
]
}
```
------
# Conceder acceso de lectura y escritura a los objetos del bucket de Amazon S3
En este ejemplo se muestra cómo podría crear una política basada en identidades que permita el acceso de `Read` y `Write` a objetos de un bucket de Amazon S3 específico. Esta política concede los permisos necesarios para llevar a cabo esta acción mediante programación desde la API o la AWS CLI de AWS. Para utilizar esta política, sustituya el *texto en cursiva del marcador* de la política de ejemplo con su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
La acción `s3:*Object` utiliza un comodín como parte del nombre de la acción. La instrucción `AllObjectActions` permite `GetObject`, `DeleteObject`, `PutObject` y cualquier otra acción de Amazon S3 que termine con la palabra "Object".
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ListObjectsInBucket",
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::bucket-name"]
},
{
"Sid": "AllObjectActions",
"Effect": "Allow",
"Action": "s3:*Object",
"Resource": ["arn:aws:s3:::bucket-name/*"]
}
]
}
```
------
**nota**
Para permitir el acceso a `Read` y `Write` a un objeto en un bucket de Amazon S3 y también incluir permisos adicionales para el acceso a la consola, consulte [Amazon S3: permite el acceso de lectura y escritura a objetos en un bucket de S3 mediante programación y en la consola](reference_policies_examples_s3_rw-bucket-console.md).
# Amazon S3: permite el acceso de lectura y escritura a objetos en un bucket de S3 mediante programación y en la consola
En este ejemplo se muestra cómo podría crear una política basada en identidad que permita a `Read` y a `Write` acceder a objetos de un bucket de S3 específico. Esta política define los permisos para el acceso programático y a la consola. Para utilizar esta política, sustituya el *texto en cursiva* de la política de ejemplo por su propia información. A continuación, siga las instrucciones en [Crear una política](access_policies_create.md) o [Editar una política](access_policies_manage-edit.md).
La acción `s3:*Object` utiliza un comodín como parte del nombre de la acción. La instrucción `AllObjectActions` permite `GetObject`, `DeleteObject`, `PutObject` y cualquier otra acción de Amazon S3 que termine con la palabra "Object".
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "S3ConsoleAccess",
"Effect": "Allow",
"Action": [
"s3:GetAccountPublicAccessBlock",
"s3:GetBucketAcl",
"s3:GetBucketLocation",
"s3:GetBucketPolicyStatus",
"s3:GetBucketPublicAccessBlock",
"s3:ListAccessPoints",
"s3:ListAllMyBuckets"
],
"Resource": "*"
},
{
"Sid": "ListObjectsInBucket",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket"]
},
{
"Sid": "AllObjectActions",
"Effect": "Allow",
"Action": "s3:*Object",
"Resource": ["arn:aws:s3:::amzn-s3-demo-bucket/*"]
}
]
}
```
------