• El panel de AWS Systems Manager CloudWatch dejará de estar disponible después del 30 de abril de 2026. Los clientes pueden seguir utilizando la consola de Amazon CloudWatch para ver, crear y administrar sus paneles de Amazon CloudWatch, tal y como lo hacen actualmente. Para obtener más información, consulte la [documentación del panel de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html).
# AWS Systems Manager Run Command
Con Run Command, una herramienta de AWS Systems Manager, puede administrar de forma remota y segura la configuración de los nodos administrados. Un *nodo administrado* es cualquier instancia de Amazon Elastic Compute Cloud (Amazon EC2) o cualquier máquina que no sea de EC2, en su entorno [híbrido y multinube](operating-systems-and-machine-types.md#supported-machine-types), que se haya configurado para Systems Manager. Run Command permite automatizar las tareas administrativas comunes y realizar cambios de configuración de una sola vez a escala. Puede utilizar Run Command desde la Consola de administración de AWS, la AWS Command Line Interface (AWS CLI), AWS Tools for Windows PowerShell o los AWS SDK. Run Command se ofrece sin costo adicional. Para comenzar a utilizar Run Command, abra la [consola de Systems Manager](https://console.aws.amazon.com//systems-manager/run-command). En el panel de navegación, elija **Run Command**.
Los administradores utilizan Run Command instalar o arrancar aplicaciones, crear una canalización de implementación, capturar archivos de registros cuando se elimina una instancia de un grupo de escalado automático, unir instancias a un dominio de Windows, y más.
La API de Run Command sigue un modelo de consistencia final debido a la naturaleza distribuida del sistema que admite la API. Esto significa que el resultado de ejecutar un comando de API que afecte a los recursos que tiene podría no estar inmediatamente visible para todos los comandos posteriores que ejecute. Debe tenérselo en cuenta cuando se ejecute un comando de API que siga inmediatamente a un comando de API anterior.
**Introducción**
En la siguiente tabla, se incluye información para ayudarlo a comenzar a utilizar Run Command.
****
| Topic | Details |
| --- | --- |
| [Configuración de nodos administrados para AWS Systems Manager](systems-manager-setting-up-nodes.md) | Verifique que haya completado los requisitos de configuración para las instancias de Amazon Elastic Compute Cloud (Amazon EC2) y las máquinas que no sean de EC2 en un entorno [híbrido y multinube.](operating-systems-and-machine-types.md#supported-machine-types) |
| [Administrador de nodos en entornos híbridos y multinube con Systems Manager](systems-manager-hybrid-multicloud.md) | (Opcional) Registre los servidores locales y las máquinas virtuales en AWS para poder administrarlos con Run Command. |
| [Administración de dispositivos periféricos con Systems Manager](systems-manager-setting-up-edge-devices.md) | (Opcional) Configure dispositivos de borde para que pueda administrarlos mediante Run Command. |
| [Ejecución de comandos en nodos administrados](running-commands.md) | Obtenga información sobre cómo ejecutar un comando que se dirige a uno o varios nodos administrados mediante la Consola de administración de AWS. |
| [Tutoriales de Run Command](run-command-walkthroughs.md) | Aprenda cómo ejecutar comandos mediante Tools for Windows PowerShell o la AWS CLI. |
**Compatibilidad con EventBridge**
Esta herramienta de Systems Manager se admite como un tipo de *evento* y un tipo de *destino* en las reglas de Amazon EventBridge. Para obtener más información, consulte [Cómo monitorear eventos de Systems Manager con Amazon EventBridge](monitoring-eventbridge-events.md) y [Referencia: patrones y tipos de eventos de Amazon EventBridge para Systems Manager](reference-eventbridge-events.md).
**Más información**
+ [Remotely Run Command on an EC2 Instance (10 minute tutorial)](https://aws.amazon.com/getting-started/hands-on/remotely-run-commands-ec2-instance-systems-manager/) (Uso remoto de Run Command en una instancia de EC2 [tutorial de 10 minutos])
+ [Service Quotas de Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) en la *Referencia general de Amazon Web Services*
+ [AWS Systems Manager Referencia de la API de](https://docs.aws.amazon.com/systems-manager/latest/APIReference/)
**Topics**
+ [Cómo configurar Run Command](run-command-setting-up.md)
+ [Ejecución de comandos en nodos administrados](running-commands.md)
+ [Uso de códigos de salida en los comandos](run-command-handle-exit-status.md)
+ [Descripción de los estados del comando](monitor-commands.md)
+ [Tutoriales de Run Command](run-command-walkthroughs.md)
+ [Solución de problemas Systems Manager Run Command](troubleshooting-remote-commands.md)
# Cómo configurar Run Command
Antes de poder administrar nodos con Run Command, una herramienta de AWS Systems Manager, debe configurar una política de AWS Identity and Access Management (IAM) para todos los usuarios que vayan a ejecutar comandos. Si utiliza alguna clave de condición global para la acción `SendCommand` en sus políticas de IAM, debe incluir la clave de condición `aws:ViaAWSService` y establecer el valor booleano en `true`. A continuación se muestra un ejemplo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"StringEquals": {
"aws:SourceVpce": [
"vpce-1234567890abcdef0"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"Bool": {
"aws:ViaAWSService": "true"
}
}
}
]
}
```
------
También debe configurar los nodos para Systems Manager. Para obtener más información, consulte [Configuración de nodos administrados para AWS Systems Manager](systems-manager-setting-up-nodes.md).
Le recomendamos completar las siguientes tareas de configuración opcionales para ayudar a minimizar la posición de seguridad y la gestión diaria de los nodos administrados.
Monitoreo de la ejecución de comandos con Amazon EventBridge
Puede utilizar EventBridge para registrar los cambios de estado de la ejecución de comandos. Tiene la opción de crear una regla que se ejecute siempre que haya una transición de estado o cuando haya una transición a uno o varios estados de interés. También puede especificar Run Command como una acción de destino cuando se produce un evento de EventBridge. Para obtener más información, consulte [Configuración de EventBridge para eventos de Systems Manager](monitoring-systems-manager-events.md).
Monitoreo de la ejecución de comandos con los Registros de Amazon CloudWatch
Puede configurar Run Command para que envíe periódicamente todos los resultados y los registros de errores de los comandos a un grupo de registros de Amazon CloudWatch. Puede monitorizar estos registros de salida prácticamente en tiempo real, buscar frases, valores o patrones específicos y crear alarmas en función de la búsqueda. Para obtener más información, consulte [Configuración de Registros de Amazon CloudWatch para Run Command](sysman-rc-setting-up-cwlogs.md).
Restrinja el acceso de Run Command a nodos administrados específicos
Puede restringir la capacidad de un usuario para ejecutar comandos en nodos administrados mediante AWS Identity and Access Management (IAM). En concreto, puede crear una política de IAM con la condición de que el usuario solo pueda ejecutar comandos en nodos administrados que estén etiquetados con etiquetas específicas. Para obtener más información, consulte [Restricción de acceso de Run Command basado en etiquetas](#tag-based-access).
## Restricción de acceso de Run Command basado en etiquetas
En esta sección se describe cómo restringir la capacidad de un usuario para ejecutar comandos en nodos administrados especificando una condición de etiqueta en una política de IAM. Los nodos administrados incluyen instancias de Amazon EC2 y nodos que no son de EC2 en un entorno [híbrido y multinube](operating-systems-and-machine-types.md#supported-machine-types) configurado para Systems Manager. Aunque la información no se presenta explícitamente, también puede restringir el acceso a dispositivos de núcleo administrados de AWS IoT Greengrass. Para comenzar, debe etiquetar los dispositivos de AWS IoT Greengrass. Para obtener más información, consulte [Etiquetar los recursos de AWS IoT Greengrass Version 2](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) en la *Guía para desarrolladores de AWS IoT Greengrass Version 2*.
Puede restringir la ejecución de comandos a determinados nodos administrados mediante la creación de una política de IAM que incluya la condición de que el usuario solo pueda ejecutar comandos en los nodos que tengan determinadas etiquetas. En el ejemplo siguiente, el usuario tiene permitido utilizar Run Command (`Effect: Allow, Action: ssm:SendCommand`) mediante cualquier documento de SSM (`Resource: arn:aws:ssm:*:*:document/*`) en cualquier nodo (`Resource: arn:aws:ec2:*:*:instance/*`) con la condición de que el nodo sea un servidor web de finanzas (`ssm:resourceTag/Finance: WebServer`). Si el usuario envía un comando a un nodo que no está etiquetado o que tiene una etiqueta que no es `Finance: WebServer`, los resultados de la ejecución mostrarán `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:*:*:document/*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ec2:*:*:instance/*"
],
"Condition":{
"StringLike":{
"ssm:resourceTag/Finance":[
"WebServers"
]
}
}
}
]
}
```
------
Puede crear políticas de IAM que permitan al usuario ejecutar comandos en los nodos administrados etiquetados con varias etiquetas. La siguiente política permite al usuario ejecutar comandos en nodos administrados que tienen dos etiquetas. Si un usuario envía un comando a un nodo que no está etiquetado con estas dos etiquetas, los resultados de la ejecución mostrarán `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
],
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
También puede crear políticas de IAM que permitan al usuario ejecutar comandos en varios grupos de nodos administrados etiquetados. La siguiente política de ejemplo permite al usuario ejecutar comandos en uno de los grupos de nodos etiquetados o en ambos grupos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Para obtener más información acerca de la creación de políticas de IAM, consulte [Políticas administradas y políticas insertadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html) en la *Guía del usuario de IAM*. Para obtener más información acerca del etiquetado de nodos administrados, consulte [Editor de etiquetas](https://docs.aws.amazon.com/ARG/latest/userguide/tag-editor.html) en la *Guía del usuario de Grupos de recursos de AWS*.
# Ejecución de comandos en nodos administrados
Esta sección contiene información sobre cómo enviar comandos desde la consola de AWS Systems Manager a nodos administrados. La sección también incluye información acerca de cómo cancelar un comando.
Tenga en cuenta que siisu nodo está configurado con la opción de montaje `noexec` para el directorio var, Run Command no podrá ejecutar correctamente los comandos.
**importante**
Cuando ejecute un comando con Run Command, no incluya información confidencial como texto sin formato, por ejemplo, contraseñas, datos de configuración u otros secretos. Toda la actividad de la API de Systems Manager de la cuenta se registra en un bucket de S3, para registros de AWS CloudTrail. Esto significa que cualquier usuario con acceso al bucket de S3 puede ver los valores en texto sin formato de esos secretos. Por este motivo, le recomendamos crear y utilizar parámetros `SecureString` para cifrar la información confidencial que utiliza en las operaciones de Systems Manager.
Para obtener más información, consulte [Restringir el acceso a los parámetros de Parameter Store mediante políticas de IAM](sysman-paramstore-access.md).
**Retención del historial de ejecución**
El historial de cada comando está disponible durante un máximo de 30 días. Además, puede almacenar una copia de todos los archivos de registro en Amazon Simple Storage Service o disponer de un registro de auditoría de todas las llamadas de API en AWS CloudTrail.
**Información relacionada**
Para obtener más información acerca de cómo enviar comandos con otras herramientas, consulte los siguientes temas:
+ [Tutorial: uso de la AWS Tools for Windows PowerShell con Run Command](walkthrough-powershell.md) o consulte los ejemplos de la [sección de AWS Systems Manager de Referencia de Cmdlet de Herramientas de AWS para PowerShell](https://docs.aws.amazon.com/powershell/latest/reference/items/AWS_Systems_Manager_cmdlets.html).
+ [Tutorial: uso de la AWS CLI con Run Command](walkthrough-cli.md) o los ejemplos de la [Referencia de la CLI de SSM](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
**Topics**
+ [Ejecución de comandos desde la consola](running-commands-console.md)
+ [Ejecución de comandos mediante una versión de documento específica](run-command-version.md)
+ [Ejecución de comandos a escala](send-commands-multiple.md)
+ [Cancelación de un comando](cancel-run-command.md)
# Ejecución de comandos desde la consola
Puede utilizar Run Command, una herramienta de AWS Systems Manager, desde la Consola de administración de AWS para configurar nodos administrados sin tener que iniciar sesión en ellos. En este tema, se incluye un ejemplo en el que se muestra cómo [actualizar SSM Agent](run-command-tutorial-update-software.md#rc-console-agentexample) en un nodo administrado utilizando Run Command.
**Antes de empezar**
Antes de enviar un comando con Run Command, verifique que los nodos administrados cumplan los [requisitos de configuración](systems-manager-setting-up-nodes.md) de Systems Manager.
**Para enviar un comando con Run Command**
1. Abra la consola de AWS Systems Manager en [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. En el panel de navegación, elija **Run Command**.
1. Elija **Run command (Ejecutar comando)**.
1. En la lista **Command document** (Documento de Command), elija un documento de Systems Manager.
1. En la sección **Command Parameters**, especifique los valores de los parámetros obligatorios.
1. En la sección **Targets** (Destinos), para elegir los nodos administrados en los que desea ejecutar esta operación, especifique las etiquetas, seleccione las instancias o los dispositivos de borde manualmente o especifique un grupo de recursos.
**sugerencia**
Si un nodo administrado que espera ver no aparece en la lista, consulte [Solución de problemas de disponibilidad de nodos administrados](fleet-manager-troubleshooting-managed-nodes.md) para obtener consejos de solución de problemas.
1. En **Otros parámetros**:
+ En **Comentario**, ingrese la información acerca de este comando.
+ En **Tiempo de espera (segundos)**, especifique el número de segundos que tiene que esperar el sistema antes de indicar que se ha producido un error en la ejecución del comando general.
1. En **Rate control** (Control de velocidad):
+ En **Concurrency** (Simultaneidad), especifique un número o un porcentaje de los nodos administrados en los que desea ejecutar el comando al mismo tiempo.
**nota**
Si seleccionó los destinos mediante la especificación de etiquetas aplicadas a nodos administrados o de grupos de recursos de AWS y no está seguro de cuántos nodos administrados tienen destino, limite el número de destinos que puede ejecutar el documento al mismo tiempo. Para ello, especifique un porcentaje.
+ En **Error threshold** (Umbral de errores), especifique cuándo desea parar la ejecución del comando en los demás nodos administrados después de que haya fallado en un número o un porcentaje de los nodos. Por ejemplo, si especifica tres errores, Systems Manager dejará de enviar el comando cuando se reciba el cuarto error. Los nodos administrados que estén procesando el comando todavía pueden enviar errores.
1. (Opcional) Elija una alarma de CloudWatch que desee aplicar al comando para fines de monitoreo. Para adjuntar una alarma de CloudWatch a su comando, la entidad principal de IAM que lo ejecute debe tener permiso para la acción `iam:createServiceLinkedRole`. Para obtener más información sobre las alarmas de CloudWatch, consulte [Uso de alarmas de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html). Tenga en cuenta que si la alarma se activa, no se ejecutará ninguna invocación de comando pendiente.
1. (Opcional) En **Opciones de salida**, para guardar la salida del comando en un archivo, seleccione el cuadro **Write command output to an S3 bucket**. Ingrese los nombres del bucket y del prefijo (carpeta) en los cuadros.
**nota**
Los permisos de S3 que conceden la capacidad de escribir datos en un bucket de S3 son los del perfil de instancia (para instancias de EC2) o rol de servicio de IAM (máquinas activadas de manera híbrida) asignados a la instancia, no los del usuario de IAM que realiza esta tarea. Para obtener más información, consulte [Configuración de permisos de instancia requeridos para Systems Manager](setup-instance-permissions.md) o [Creación de un rol de servicio de IAM para un entorno híbrido](hybrid-multicloud-service-role.md). Además, si el bucket de S3 especificado se encuentra en una Cuenta de AWS diferente, asegúrese de que el perfil de instancias o el rol de servicio de IAM asociado al nodo administrado tenga los permisos necesarios para escribir en ese bucket.
1. En la sección **Notificaciones de SNS**, seleccione la casilla de verificación **Habilitar notificaciones de SNS** si desea recibir notificaciones sobre el estado de ejecución de los comandos.
Para obtener más información acerca de la configuración de las notificaciones de Amazon SNS para Run Command, consulte [Cómo monitorear los cambios de estado de Systems Manager mediante las notificaciones de Amazon SNS](monitoring-sns-notifications.md).
1. Seleccione **Ejecutar**.
Para obtener más información acerca de la cancelación de un comando, consulte [Cancelación de un comando](cancel-run-command.md).
## Volver a ejecutar comandos
Systems Manager incluye dos opciones que lo ayudarán a volver a ejecutar un comando desde la página de **Run Command** en la consola de Systems Manager.
+ **Rerun** (Volver a ejecutar): este botón le permite ejecutar el mismo comando sin realizarle cambios.
+ **Copy to new (Copiar en nuevo)**: este botón copia la configuración de un comando en un comando nuevo y le ofrece la opción de editar esa configuración antes de ejecutarlo.
**Para volver a ejecutar un comando**
1. Abra la consola de AWS Systems Manager en [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. En el panel de navegación, elija **Run Command**.
1. Elija el comando que desea volver a ejecutar. Puede volver a ejecutar un comando inmediatamente después de ejecutarlo desde la página de detalles del comando. O bien, puede elegir un comando que haya ejecutado anteriormente en la pestaña **Command history** (Historial de comandos).
1. Elija **Rerun (Volver a ejecutar)** para ejecutar el mismo comando sin realizar ningún cambio o elija **Copy to new (Copiar en nuevo)** para editar la configuración del comando antes de ejecutarlo.
# Ejecución de comandos mediante una versión de documento específica
Puede utilizar el parámetro document-version para especificar la versión de un documento de AWS Systems Manager que se va a usar cuando se ejecute el comando. Puede especificar una de las opciones siguientes para este parámetro:
+ \$1DEFAULT
+ \$1LATEST
+ Número de versión
Lleve a cabo el siguiente procedimiento para ejecutar un comando utilizando el parámetro de versión del documento.
------
#### [ Linux ]
**Para ejecutar comandos mediante la AWS CLI en equipos locales con Linux**
1. Si aún no lo ha hecho, instale y configure la AWS Command Line Interface (AWS CLI).
Para obtener más información, consulte [Instalación o actualización de la última versión de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Enumerar todos los documentos disponibles
Este comando enumera todos los documentos disponibles para su cuenta en función de los permisos de AWS Identity and Access Management (IAM).
```
aws ssm list-documents
```
1. Ejecute el siguiente comando para ver las diferentes versiones de un documento. Reemplace el *nombre del documento* con su propia información.
```
aws ssm list-document-versions \
--name "document name"
```
1. Utilice el siguiente comando para ejecutar un comando que utilice una versión del documento de SSM. Reemplace cada *example resource placeholder* con su propia información.
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--parameters commands="echo Hello" \
--instance-ids instance-ID \
--document-version '$LATEST'
```
------
#### [ Windows ]
**Para ejecutar comandos mediante la AWS CLI en equipos locales con Windows**
1. Si aún no lo ha hecho, instale y configure la AWS Command Line Interface (AWS CLI).
Para obtener más información, consulte [Instalación o actualización de la última versión de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Enumerar todos los documentos disponibles
Este comando enumera todos los documentos disponibles para su cuenta en función de los permisos de AWS Identity and Access Management (IAM).
```
aws ssm list-documents
```
1. Ejecute el siguiente comando para ver las diferentes versiones de un documento. Reemplace el *nombre del documento* con su propia información.
```
aws ssm list-document-versions ^
--name "document name"
```
1. Utilice el siguiente comando para ejecutar un comando que utilice una versión del documento de SSM. Reemplace cada *example resource placeholder* con su propia información.
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--parameters commands="echo Hello" ^
--instance-ids instance-ID ^
--document-version "$LATEST"
```
------
#### [ PowerShell ]
**Para ejecutar comandos con Tools for PowerShell**
1. Instale y configure Herramientas de AWS para PowerShell (Herramientas para Windows PowerShell), si aún no lo ha hecho.
Para obtener más información, consulte [Instalación de Herramientas de AWS para PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
1. Enumerar todos los documentos disponibles
Este comando enumera todos los documentos disponibles para su cuenta en función de los permisos de AWS Identity and Access Management (IAM).
```
Get-SSMDocumentList
```
1. Ejecute el siguiente comando para ver las diferentes versiones de un documento. Reemplace el *nombre del documento* con su propia información.
```
Get-SSMDocumentVersionList `
-Name "document name"
```
1. Utilice el siguiente comando para ejecutar un comando que utilice una versión del documento de SSM. Reemplace cada *example resource placeholder* con su propia información.
```
Send-SSMCommand `
-DocumentName "AWS-RunShellScript" `
-Parameter @{commands = "echo helloWorld"} `
-InstanceIds "instance-ID" `
-DocumentVersion $LATEST
```
------
# Ejecución de comandos a escala
Puede utilizar Run Command, una herramienta de AWS Systems Manager, para ejecutar comandos en una flota de nodos administrados mediante `targets`. El parámetro `targets` acepta una combinación de `Key,Value` basada en las etiquetas que haya especificado en los nodos administrados. Al ejecutar el comando, el sistema localiza e intenta ejecutar dicho comando en todos los nodos administrados que coinciden con las etiquetas especificadas. Para obtener más información sobre el etiquetado de instancias administradas consulte, [Etiquetado de recursos de AWS](https://docs.aws.amazon.com/tag-editor/latest/userguide/tag-editor.html) en la *Guía del usuario de Etiquetado de recursos de AWS*. Para obtener más información acerca del etiquetado de dispositivos IoT administrados, consulte [Etiquetado de recursos de AWS IoT Greengrass Version 2](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) en la *Guía para desarrolladores de AWS IoT Greengrass Version 2*.
También puede utilizar el parámetro `targets` para dirigirse a una lista de ID de nodos administrados específicos, tal y como se describe en la sección siguiente.
Para controlar la forma en que los comandos ejecutan cientos o miles de nodos administrados, Run Command también incluye parámetros con el fin de restringir cuántos nodos puede procesar una solicitud simultáneamente y qué cantidad de errores puede generar un comando antes de finalizar.
**Topics**
+ [Indicar destino de varios nodos administrados](#send-commands-targeting)
+ [Cómo utilizar controles de velocidad](#send-commands-rate)
## Indicar destino de varios nodos administrados
Puede ejecutar un comando y dirigirse a nodos administrados especificando etiquetas, nombres de grupos de recursos de AWS o ID de nodos administrados.
En los siguientes ejemplos, se muestra el formato de comandos cuando se utiliza Run Command desde la AWS Command Line Interface (AWS CLI ). Reemplace cada *example resource placeholder* con su propia información. Los ejemplos de comandos de esta sección se truncan con `[...]`.
**Ejemplo 1: dirigirse a etiquetas**
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:tag-name,Values=tag-value \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:tag-name,Values=tag-value ^
[...]
```
------
**Ejemplo 2: dirigirse a un grupo de recursos de AWS por nombre**
Puede especificar un máximo de un nombre de grupo de recursos por comando. Al crear un grupo de recursos, le recomendamos que incluya `AWS::SSM:ManagedInstance` y `AWS::EC2::Instance` como tipos de recursos en sus criterios de creación de grupo.
**nota**
Con el fin de enviar comandos que tengan como destino un grupo de recursos, debe haber recibido los permisos de AWS Identity and Access Management (IAM) para mostrar o ver los recursos que pertenecen a ese grupo. Para obtener más información, consulte la sección [Configuración de permisos](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) en la *Guía del usuario de Grupos de recursos de AWS*.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:Name,Values=resource-group-name \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:Name,Values=resource-group-name ^
[...]
```
------
**Ejemplo 3: dirigirse a un grupo de recursos de AWS por tipo de recurso**
Puede especificar un máximo de cinco tipos de grupos de recursos por comando. Al crear un grupo de recursos, le recomendamos que incluya `AWS::SSM:ManagedInstance` y `AWS::EC2::Instance` como tipos de recursos en sus criterios de creación de grupo.
**nota**
Con el fin de enviar comandos que tienen como destino un grupo de recursos, se le deben haber concedido los permisos de IAM para mostrar o ver los recursos que pertenecen a ese grupo. Para obtener más información, consulte la sección [Configuración de permisos](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) en la *Guía del usuario de Grupos de recursos de AWS*.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 ^
[...]
```
------
**Ejemplo 4: dirigirse a ID de instancias**
En los siguientes ejemplos, se muestra cómo dirigirse a nodos administrados mediante la clave de `instanceids` con el parámetro `targets`. Puede utilizar esta clave para dirigirse a dispositivos de núcleo de AWS IoT Greengrass administrados porque a cada dispositivo se le asigna un mi-*Id\$1number*. Puede ver los ID de los dispositivos en Fleet Manager, una herramienta de AWS Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 ^
[...]
```
------
Si ha etiquetado nodos administrados para diferentes entornos utilizando una `Key` denominada `Environment` y `Values` de `Development`, `Test`, `Pre-production` y `Production`, podría enviar un comando a todos los nodos administrados que se encuentren en *uno* de estos entornos mediante el uso del parámetro `targets` con la siguiente sintaxis.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
------
Podría dirigirse a nodos administrados adicionales en otros entornos agregando elementos a la lista `Values`. Separe los elementos mediante comas.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development,Test,Pre-production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development,Test,Pre-production ^
[...]
```
------
**Variación**: refinado de los destinos con varios criterios `Key`
Puede refinar el número de destinos para el comando incluyendo varios criterios `Key`. Si incluye más de un criterio de `Key`, el sistema se dirige a los nodos administrados que cumplen *todos* los criterios. El siguiente comando se dirige a todos los nodos administrados etiquetados para el Departamento de Finanzas *y* etiquetados para el rol de servidor de base de datos.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database ^
[...]
```
------
**Variación **: uso de varios criterios `Key` y `Value`
Profundizando en el ejemplo anterior, puede dirigirse a varios departamentos y diversas roles de servidor mediante la inclusión de elementos adicionales en el criterio `Values`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
**Variación**: dirigirse a nodos administrados etiquetados mediante varios criterios de `Values`
Si etiquetó nodos administrados para diferentes entornos utilizando una `Key` denominada `Department` y `Values` de `Sales` y `Finance`, podría enviar un comando a todos los nodos administrados de estos entornos mediante el uso del parámetro `targets` con la siguiente sintaxis.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Sales,Finance \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Sales,Finance ^
[...]
```
------
Puede especificar un máximo de cinco claves y cinco valores para cada clave.
Si una clave de etiqueta (el nombre de la etiqueta) o un valor de etiqueta incluye espacios, deberá encerrar la clave de etiqueta o el valor entre comillas, como se muestra en los siguientes ejemplos.
**Ejemplo**: espacios en la etiqueta `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:OS,Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:OS,Values="Windows Server 2016" ^
[...]
```
------
**Ejemplo**: espacios en la clave y `Value` de una `tag`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key="tag:Operating System",Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key="tag:Operating System",Values="Windows Server 2016" ^
[...]
```
------
**Ejemplo**: espacios en un elemento de una lista de `Values`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" ^
[...]
```
------
## Cómo utilizar controles de velocidad
Puede controlar la velocidad a la que se envían los comandos a los nodos administrados de un grupo mediante *controles de simultaneidad * y *controles de error*.
**Topics**
+ [Uso de controles de simultaneidad](#send-commands-velocity)
+ [Uso de controles de error](#send-commands-maxerrors)
### Uso de controles de simultaneidad
Puede controlar el número de nodos administrados que ejecutan el comando al mismo tiempo mediante el parámetro `max-concurrency` (las opciones de **Concurrency** [Simultaneidad] de la página **Run a command** [Ejecutar un comando]). Puede especificar un número absoluto de nodos administrados, por ejemplo, **10**, o un porcentaje del destino definido, por ejemplo, **10%**. El sistema de colas entrega el comando a un único nodo y espera hasta que el sistema confirme la invocación inicial antes de enviar el comando a dos nodos más. El sistema envía comandos de forma exponencial a más nodos hasta que alcanza el valor de `max-concurrency`. El valor predeterminado del valor de `max-concurrency` es 50. Los siguientes ejemplos le muestran cómo especificar valores para el parámetro `max-concurrency`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10 \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10% \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10 ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10% ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
### Uso de controles de error
También puede controlar la ejecución de un comando para cientos o miles de nodos administrado al configurar un límite de error mediante los parámetros `max-errors` (el campo **Error threshold** [Umbral de error] de la página **Run a command** [Ejecutar un comando]). El parámetro especifica la cantidad de errores que están permitidos antes de que el sistema detenga el envío del comando a nodos administrados adicionales. Puede especificar un número absoluto de errores, por ejemplo, **10**, o un porcentaje del destino definido, por ejemplo, **10%**. Si especifica **3**, por ejemplo, el sistema dejará de enviar el comando cuando se reciba el cuarto error. Si especifica **0**, el sistema dejará de enviar el comando a otros nodos administrados tras el primer resultado de error que se devuelva. Si envía un comando a 50 nodos administrados y configura `max-errors` en un **10%**, el sistema dejará de enviar el comando a otros nodos cuando se reciba el sexto error.
Las invocaciones que ya están ejecutando un comando cuando se alcanza el `max-errors` tienen permiso para completarse, pero algunas de estas invocaciones también pueden producir errores. Si necesita asegurarse de que no habrá más de `max-errors` invocaciones erróneas, establezca `max-concurrency` en **1**, de modo que las invocaciones continuarán de una en una. El valor predeterminado para max-errors es 0. Los siguientes ejemplos le muestran cómo especificar valores para el parámetro `max-errors`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-errors 10 \
--targets Key=tag:Database,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-errors 10% \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 1 \
--max-errors 1 \
--targets Key=tag:Environment,Values=Production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10 ^
--targets Key=tag:Database,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10% ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 1 ^
--max-errors 1 ^
--targets Key=tag:Environment,Values=Production ^
[...]
```
------
# Cancelación de un comando
Puede intentar cancelar un comando siempre y cuando el servicio muestre que está en estado pendiente o en ejecución. Sin embargo, incluso si un comando todavía tiene alguno de estos estados, no se puede garantizar que el comando se cancelerá y el proceso subyacente se detendrá.
**Para cancelar un comando con la consola**
1. Abra la consola de AWS Systems Manager en [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. En el panel de navegación, elija **Run Command**.
1. Seleccione la invocación del comando que desea cancelar.
1. Elija **Cancel Command**.
**Para cancelar un comando con la AWS CLI**
Ejecute el siguiente comando de la . Reemplace cada *example resource placeholder* con su propia información.
------
#### [ Linux & macOS ]
```
aws ssm cancel-command \
--command-id "command-ID" \
--instance-ids "instance-ID"
```
------
#### [ Windows ]
```
aws ssm cancel-command ^
--command-id "command-ID" ^
--instance-ids "instance-ID"
```
------
Para obtener más información acerca del estado de un comando cancelado, consulte [Descripción de los estados del comando](monitor-commands.md).
# Uso de códigos de salida en los comandos
En algunos casos, es posible que necesite administrar cómo se gestionan los comandos mediante el uso de códigos de salida.
## Especificación de códigos de salida en los comandos
Con Run Command, una herramienta de AWS Systems Manager, puede especificar códigos de salida para determinar cómo se gestionan los comandos. De forma predeterminada, el código de salida del último comando ejecutado en un script se registra como el código de salida de todo el script. Suponga, por ejemplo, que tiene un scripts que contiene tres comandos. El primero da un error, pero los demás se ejecutan correctamente. Como el comando final se ejecutó correctamente, el estado de la ejecución se registra como `succeeded`.
**Scripts de shell**
Para que todo el script produzca un error en el primer error del comando, puede incluir una declaración condicional de intérprete para salir del script si algún comando anterior al último produce un error. Utilice el siguiente enfoque.
```
if [ $? != 0 ]
then
exit
fi
```
En el ejemplo siguiente, se produce un error en todo el script si se produce un error en el primer comando.
```
cd /test
if [ $? != 0 ]
then
echo "Failed"
exit 1
fi
date
```
**Scripts de PowerShell**
PowerShell requiere que llame explícitamente a `exit` en sus scripts para que Run Command capture correctamente el código de salida.
```
if ($?) {}
else {exit }
exit
```
A continuación se muestra un ejemplo:
```
cd C:\
if ($?) {echo "Success"}
else {exit 1}
date
```
# Gestión de reinicios al ejecutar comandos
Si utiliza Run Command, una herramienta de AWS Systems Manager, para ejecutar scripts que reinician nodos administrados, le recomendamos que especifique un código de salida en el script. Si intenta utilizar algún otro mecanismo para reiniciar un nodo desde un script, el estado de ejecución de ese script podría no actualizarse correctamente, aunque el reinicio sea el último paso del script. Para los nodos administrados de Windows, especifique `exit 3010` en el script. Para los nodos administrados de Linux y macOS, especifique `exit 194`. El código de salida indica al agente AWS Systems Manager (SSM Agent) que reinicie el nodo administrado y, a continuación, cuando esa operación haya finalizado, reinicie el script. Antes de comenzar el reinicio, el SSM Agent informará al servicio Systems Manager en la nube que la comunicación se va a interrumpir mientras se reinicia el servidor.
**nota**
El script de reinicio no puede formar parte de un complemento `aws:runDocument`. Si un documento contiene el script de reinicio y otro documento intenta ejecutarlo a través del complemento `aws:runDocument`, SSM Agent devuelve un error.
**Creación de scripts idempotentes**
Al desarrollar scripts que se utilizan para reiniciar nodos administrados, es importante que se asegure de que estos sean idempotentes para que, una vez finalizado el reinicio, la ejecución de los scripts continúe en el punto en que se encontraban anteriormente. Los scripts idempotentes administran el estado y validan si la acción se ha realizado o no. Esto impide que un paso se ejecute varias veces cuando solo está diseñado para ejecutarse una vez.
A continuación, se muestra un ejemplo resumido de un script idempotente que reinicia el nodo administrado varias veces.
```
$name = Get current computer name
If ($name –ne $desiredName)
{
Rename computer
exit 3010
}
$domain = Get current domain name
If ($domain –ne $desiredDomain)
{
Join domain
exit 3010
}
If (desired package not installed)
{
Install package
exit 3010
}
```
**Ejemplos**
En los ejemplos de scripts siguientes, se utilizan códigos de salida para reiniciar nodos administrados. En el ejemplo de Linux, se instalan actualizaciones de paquetes en Amazon Linux y, a continuación, se reinicia el nodo. En el ejemplo de Windows Server, se instala Telnet-Client en el nodo y a continuación se reinicia.
------
#### [ Amazon Linux 2 ]
```
#!/bin/bash
yum -y update
needs-restarting -r
if [ $? -eq 1 ]
then
exit 194
else
exit 0
fi
```
------
#### [ Windows ]
```
$telnet = Get-WindowsFeature -Name Telnet-Client
if (-not $telnet.Installed)
{
# Install Telnet and then send a reboot request to SSM Agent.
Install-WindowsFeature -Name "Telnet-Client"
exit 3010
}
```
------
# Descripción de los estados del comando
Run Command, una herramienta de AWS Systems Manager, ofrece información detallada sobre los diferentes estados que experimenta un comando durante el procesamiento y para cada nodo administrado que procesó el comando. Puede monitorear los estados del comando con los siguientes métodos:
+ Seleccione el icono **Refresh** (actualizar) en la pestaña **Commands** (comandos) de la interfaz de la consola de Run Command.
+ Llame a [list-commands](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-commands.html) o [list-command-invocations](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-command-invocations.html) con la AWS Command Line Interface (AWS CLI). O llame a [Get-SSMCommand](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommand.html) o [Get-SSMCommandInvocation](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommandInvocation.html) con AWS Tools for Windows PowerShell.
+ Configure Amazon EventBridge para que responda a los cambios de estado.
+ Configure Amazon Simple Notification Service (Amazon SNS) para enviar notificaciones de todos los cambios de estado o de estados específicos, como `Failed` o `TimedOut`.
## Run Commandestado
Run Command notifica los detalles de estado de tres áreas: complementos, invocaciones y un estado general del comando. Un *complemento* es un bloque de ejecución de códigos definido en el documento de SSM del comando. Para obtener más información acerca de los complementos, consulte [Referencia de complementos del documento de comandos](documents-command-ssm-plugin-reference.md).
Al enviar un comando para varios nodos administrados al mismo tiempo, cada copia del comando dirigida a cada nodo es una *invocación de comandos*. Por ejemplo, si utiliza el documento `AWS-RunShellScript` y envía un comando `ifconfig` a 20 instancias de Linux, dicho comando tendrá 20 invocaciones. Cada invocación de comandos notifica el estado individualmente. Los complementos para una invocación de comandos determinada también notifican el estado de forma individual.
Por último, Run Command contiene un estado agregado del comando para todos los complementos y las invocaciones. El estado agregado del comando puede ser diferente del estado notificado por los complementos o las invocaciones, como se describe en las siguientes tablas.
**nota**
Si ejecuta comandos para un gran número de nodos administrados utilizando los parámetros `max-concurrency` o `max-errors`, el estado del comando refleja las limitaciones impuestas por esos parámetros, tal y como se describe en las siguientes tablas. Para obtener más información sobre estos parámetros, consulte [Ejecución de comandos a escala](send-commands-multiple.md).
**Estado detallado de los complementos y las invocaciones de comandos**
| Status | Details |
| --- | --- |
| Pending (Pendiente) | El comando aún no se ha enviado al nodo administrado o no ha sido recibido por el SSM Agent. Si el agente no recibe el comando antes de que pase el tiempo que es igual a la suma del parámetro Timeout (seconds) (Tiempo de espera [en segundos]) y del parámetro Execution timeout (Tiempo de espera de ejecución), el estado cambia a Delivery Timed Out. |
| InProgress | Systems Manager está intentando enviar el comando al nodo administrado, o el comando fue recibido por SSM Agent y ha comenzado a ejecutarse en la instancia. En función del resultado de todos los complementos del comando, el estado cambiará a Success, Failed, Delivery Timed Out o Execution Timed Out. Excepción: si el agente no está en ejecución o no está disponible en el nodo, el estado del comando permanece en In Progress hasta que el agente está disponible de nuevo o hasta que se alcanza el límite de tiempo de espera de ejecución. A continuación, el estado cambiará a un estado terminal. |
| Delayed | El sistema intentó enviar el comando al nodo administrado, pero no se envió correctamente. El sistema volverá a intentarlo. |
| Success | Este estado se devuelve en diversas condiciones. Este estado no significa que el comando se procesó en el nodo. Por ejemplo, el comando puede recibirlo SSM Agent en el nodo administrado y devolver un código de salida igual a cero como resultado de que la política ExecutionPolicy de PowerShell impide la ejecución del comando. Se trata de un estado terminal. Las condiciones que provocan que un comando devuelva el estado Success son las siguientes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/systems-manager/latest/userguide/monitor-commands.html) Son de aplicación las mismas condiciones al dirigirse a grupos de recursos. Para solucionar los problemas con los errores u obtener más información acerca de la ejecución del comando, envíe un comando que administre los errores o las excepciones devolviendo códigos de salida adecuados (códigos de salida que no sean cero para los errores del comando). |
| DeliveryTimedOut | El comando no se entregó al nodo administrado antes de que se agotara el tiempo de espera total. Los tiempos de espera totales no cuentan para el límite de max-errors del comando principal, pero sí contribuyen a que el estado del comando principal sea Success, Incomplete o Delivery Timed Out. Se trata de un estado terminal. |
| ExecutionTimedOut | La automatización de comandos se inició en el nodo administrado, pero el comando no se completó antes de que se agotara el tiempo de espera de la ejecución. Agotar los tiempos de espera de las ejecuciones cuenta como un error, que enviará una respuesta distinta de cero, y Systems Manager dejará de intentar ejecutar la automatización de comandos e informará de un estado de error. |
| Failed | El comando no se ejecutó correctamente en el nodo administrado. Para un complemento, esto indica que el código de resultado no era cero. Para una invocación de comando, esto indica que el código de resultado de uno o más complementos no era cero. Los errores de invocación cuentan para el max-errors límite del comando principal. Se trata de un estado terminal. |
| Cancelado | El comando se canceló antes de completarse. Se trata de un estado terminal. |
| Undeliverable | El comando no se puede entregar al nodo administrado. Puede que no exista el nodo o que no responda. Las invocaciones no disponibles para entrega no cuentan para el límite de max-errors del comando principal, pero sí contribuyen a que el estado del comando principal sea Success o Incomplete. Por ejemplo, si todas las invocaciones de un comando tienen el estado Undeliverable, el estado del comando que se devuelve es Failed. Sin embargo, si un comando tiene cinco invocaciones, cuatro de las cuales devuelven el estado Undeliverable y una devuelve el estado Success, el estado del comando principal será Success. Se trata de un estado terminal. |
| Terminado | El comando principal supera su max-errors límite y el sistema ha cancelado las posteriores invocaciones de comandos. Se trata de un estado terminal. |
| InvalidPlatform | El comando se envió a un nodo administrado que no coincidía con las plataformas necesarias especificadas por el documento seleccionado. Invalid Platform no cuenta para el límite de máximo de errores del comando principal, pero sí contribuye a que el estado del comando principal sea Success (Correcto) o Failed (Fallido). Por ejemplo, si todas las invocaciones de un comando tienen el estado Invalid Platform, el estado del comando que se devuelve es Failed. Sin embargo, si un comando tiene cinco invocaciones, cuatro de las cuales devuelven el estado Invalid Platform y una devuelve el estado Success, el estado del comando principal será Success. Se trata de un estado terminal. |
| AccessDenied | El usuario o el rol de AWS Identity and Access Management (IAM) que inicia el comando no tiene acceso al nodo administrado de destino. Access Denied no cuenta para el límite de max-errors del comando principal, pero sí contribuye a que el estado del comando principal sea Success o Failed. Por ejemplo, si todas las invocaciones de un comando tienen el estado Access Denied, el estado del comando que se devuelve es Failed. Sin embargo, si un comando tiene cinco invocaciones, cuatro de las cuales devuelven el estado Access Denied y una devuelve el estado Success, el estado del comando principal será Success. Se trata de un estado terminal. |
**Estado detallado de un comando**
| Status | Details |
| --- | --- |
| Pending (Pendiente) | Los agentes de los nodos administrados todavía no reciben el comando. |
| InProgress | El comando se ha enviado al menos a un nodo administrado, pero no ha alcanzado un estado definitivo en ninguno de los nodos. |
| Delayed | El sistema intentó enviar el comando al nodo, pero no se envió correctamente. El sistema volverá a intentarlo. |
| Success | El comando llegó al SSM Agent de todos los nodos administrados especificados o de destino y devolvió el código de salida cero. Todas las invocaciones de comandos han alcanzado un estado terminal y no se alcanzó el valor de max-errors. Este estado no significa que el comando se haya procesado correctamente en todos los nodos administrados especificados o de destino. Se trata de un estado terminal. Para solucionar los problemas con los errores u obtener más información acerca de la ejecución del comando, envíe un comando que administre los errores o las excepciones devolviendo códigos de salida adecuados (códigos de salida que no sean cero para los errores del comando). |
| DeliveryTimedOut | El comando no se entregó al nodo administrado antes de que se agotara el tiempo de espera total. El valor de max-errors o más invocaciones de comandos muestra el estado Delivery Timed Out. Se trata de un estado terminal. |
| Failed | El comando no se ejecutó correctamente en el nodo administrado. El valor de `max-errors` o más invocaciones de comandos muestra el estado `Failed`. Se trata de un estado terminal. |
| Incomplete | El comando se intentó en todos los nodos administrados y una o más de las invocaciones no tiene el valor Success. Sin embargo, no se ha producido error en suficientes invocaciones para que el estado sea Failed. Se trata de un estado terminal. |
| Cancelado | El comando se canceló antes de completarse. Se trata de un estado terminal. |
| RateExceeded | El número de nodos administrados de destino del comando ha superado la cuota de cuenta para las invocaciones pendientes. El sistema ha cancelado el comando antes de ejecutarlo en ningún nodo. Se trata de un estado terminal. |
| AccessDenied | El usuario o el rol que inicia el comando no tiene acceso al grupo de recursos de destino. AccessDenied no cuenta para el límite de max-errors del comando principal, pero sí contribuye a que el estado del comando principal sea Success o Failed. (Por ejemplo, si todas las invocaciones de un comando tienen el estado AccessDenied, entonces el estado del comando que se devuelve es Failed. Sin embargo, si un comando tiene 5 invocaciones, 4 de las cuales devuelven el estado AccessDenied y 1 devuelve el estado Success, entonces el estado del comando principal será Success). Se trata de un estado terminal. |
| No hay instancias en la etiqueta | El grupo de recursos o el valor del par de claves de etiqueta seleccionado por el comando no coincide con ningún nodo administrado. Se trata de un estado terminal. |
## Descripción de los valores de tiempo de espera de los comandos
Systems Manager aplica los siguientes valores de tiempo de espera cuando ejecuta comandos.
**Tiempo de espera total**
En la consola de Systems Manager, especifique el valor del tiempo de espera en el campo **Timeout (seconds)** (Tiempo de espera [segundos]). Después de enviar un comando, Run Command verifica si el comando ha vencido o no. Si un comando alcanza el límite de vencimiento del comando (tiempo de espera total), cambia su estado a `DeliveryTimedOut` para todas las invocaciones que tienen el estado `InProgress`, `Pending` o `Delayed`.
![\[Campo Timeout (seconds) (Tiempo de espera [en segundos]) de la consola de Systems Manager\]](http://docs.aws.amazon.com/es_es/systems-manager/latest/userguide/images/run-command-delivery-time-out-time-out-seconds.png)
En un nivel más técnico, el tiempo de espera total —**Timeout (seconds)** (Tiempo de espera [segundos])— es una combinación de dos valores de tiempo de espera, como se muestra aquí:
`Total timeout = "Timeout(seconds)" from the console + "timeoutSeconds": "{{ executionTimeout }}" from your SSM document`
Por ejemplo, el valor predeterminado de **Timeout (seconds)** (Tiempo de espera [en segundos]) en la consola de Systems Manager es de 600 segundos. Si ejecuta un comando mediante el documento `AWS-RunShellScript` de SSM, el valor predeterminado de **"timeoutSeconds": "\$1\$1 executionTimeout \$1\$1"** es de 3600 segundos, como se muestra en el siguiente ejemplo de documento:
```
"executionTimeout": {
"type": "String",
"default": "3600",
"runtimeConfig": {
"aws:runShellScript": {
"properties": [
{
"timeoutSeconds": "{{ executionTimeout }}"
```
Esto significa que el comando se ejecuta durante 4200 segundos (70 minutos) antes de que el sistema establezca el estado del comando como `DeliveryTimedOut`.
**Tiempo de espera de la ejecución**
En la consola de Systems Manager, especifique el valor del tiempo de espera de la ejecución en el campo **Execution Timeout** (Tiempo de espera de ejecución), si está disponible. No todos los documentos de SSM requieren que especifique un tiempo de espera de ejecución. El campo **Execution Timeout** (Tiempo de espera hasta ejecución) solo se muestra cuando se ha definido un parámetro de entrada correspondiente en el documento de SSM. Si se especifica, el comando debe completarse dentro de este período de tiempo.
**nota**
Run Command se basa en la respuesta terminal del documento del SSM Agent para determinar si el comando se entregó al agente o no. SSM Agent debe enviar una señal de `ExecutionTimedOut` para que una invocación o un comando se marquen como `ExecutionTimedOut`.
![\[Campo Execution Timeout (Tiempo de espera de ejecución) de la consola de Systems Manager\]](http://docs.aws.amazon.com/es_es/systems-manager/latest/userguide/images/run-command-execution-timeout-console.png)
**Tiempo de espera de ejecución predeterminado**
Si un documento de SSM no requiere que especifique explícitamente un valor de tiempo de espera de ejecución, entonces Systems Manager aplica el tiempo de espera de ejecución de codificación rígida predeterminado.
**Cómo informa Systems Manager los tiempos de espera**
Si Systems Manager recibe una respuesta de `execution timeout` del SSM Agent de un destino, Systems Manager marca la invocación del comando como `executionTimeout`.
Si Run Command no recibe una respuesta de terminal del documento de SSM Agent, la invocación del comando se marca como `deliveryTimeout`.
Para determinar el estado del tiempo de espera en un destino, SSM Agent combina todos los parámetros y el contenido del documento de SSM para calcular el `executionTimeout`. Cuando SSM Agent determina que se ha agotado el tiempo de espera para un comando, se envía `executionTimeout` al servicio.
El valor predeterminado de **Timeout (seconds)** (Tiempo de espera [en segundos]) es de 3600 segundos. El valor predeterminado de **Execution Timeout** (Tiempo de espera de ejecución) también es de 3600 segundos. Por lo tanto, el tiempo de espera predeterminado total de un comando es de 7200 segundos.
**nota**
SSM Agent procesa el `executionTimeout` de manera diferente según el tipo de documento de SSM y la versión de este último.
# Tutoriales de Run Command
En los tutoriales de esta sección, se muestra cómo ejecutar comandos con Run Command, una herramienta de AWS Systems Manager, mediante la AWS Command Line Interface (AWS CLI) o AWS Tools for Windows PowerShell.
**Topics**
+ [Actualización del software mediante Run Command](run-command-tutorial-update-software.md)
+ [Tutorial: uso de la AWS CLI con Run Command](walkthrough-cli.md)
+ [Tutorial: uso de la AWS Tools for Windows PowerShell con Run Command](walkthrough-powershell.md)
También puede ver comandos de muestra en las siguientes referencias.
+ [Referencia de la AWS CLI de Systems Manager](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
+ [AWS Tools for Windows PowerShell - AWS Systems Manager](https://docs.aws.amazon.com/powershell/latest/reference/items/SimpleSystemsManagement_cmdlets.html)
# Actualización del software mediante Run Command
En los siguientes procedimientos se describe cómo actualizar el software en los nodos administrados.
## Actualización de SSM Agent mediante Run Command
En el siguiente procedimiento, se describe cómo actualizar el SSM Agent que se ejecuta en los nodos administrados. Puede actualizar a la versión más reciente de SSM Agent o volver a una versión anterior. Cuando se ejecuta el comando, el sistema descarga la versión de AWS, la instala y, a continuación, desinstala la versión que existía antes de ejecutar el comando. Si se produce un error durante este proceso, el sistema vuelve a la versión del servidor anterior a la ejecución del comando y el estado del comando mostrará que el comando ha tenido un error.
**nota**
Si una instancia ejecuta la versión 13.0 (Ventura) o posterior de macOS, la instancia debe tener la versión 3.1.941.0 de SSM Agent o superior para ejecutar el documento de AWS-UpdateSSMAgent. Si la instancia ejecuta una versión de SSM Agent anterior a la 3.1.941.0, puede actualizar SSM Agent para ejecutar el documento de AWS-UpdateSSMAgent si ejecuta los comandos `brew update` y `brew upgrade amazon-ssm-agent`.
Si desea recibir notificaciones sobre actualizaciones de SSM Agent, suscríbase a la página de [SSM Agent Release Notes](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) en GitHub.
**Para actualizar el SSM Agent con Run Command**
1. Abra la consola de AWS Systems Manager en [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. En el panel de navegación, elija **Run Command**.
1. Elija **Run command (Ejecutar comando)**.
1. En la lista **Command document** (Documento de Command), elija **`AWS-UpdateSSMAgent`**.
1. En la sección **Command Parameters**, especifique los valores de los parámetros siguientes, si así lo desea:
1. (Opcional) En **Version** (Versión), escriba la versión del SSM Agent que se va a instalar. Puede instalar [versiones anteriores](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) del agente. Si no especifica ninguna versión, el servicio instalará la más reciente.
1. (Opcional). En **Allow Downgrade (Permitir versiones anteriores)**, elija **true** para instalar una versión anterior del SSM Agent. Si elige esta opción, debe especificar el número de la versión [anterior](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md). Elija **false** para instalar solo la versión más reciente del servicio.
1. En la sección **Targets** (Destinos), para elegir los nodos administrados en los que desea ejecutar esta operación, especifique las etiquetas, seleccione las instancias o los dispositivos de borde manualmente o especifique un grupo de recursos.
**sugerencia**
Si un nodo administrado que espera ver no aparece en la lista, consulte [Solución de problemas de disponibilidad de nodos administrados](fleet-manager-troubleshooting-managed-nodes.md) para obtener consejos de solución de problemas.
1. En **Otros parámetros**:
+ En **Comentario**, ingrese la información acerca de este comando.
+ En **Tiempo de espera (segundos)**, especifique el número de segundos que tiene que esperar el sistema antes de indicar que se ha producido un error en la ejecución del comando general.
1. En **Rate control** (Control de velocidad):
+ En **Concurrency** (Simultaneidad), especifique un número o un porcentaje de los nodos administrados en los que desea ejecutar el comando al mismo tiempo.
**nota**
Si seleccionó los destinos mediante la especificación de etiquetas aplicadas a nodos administrados o de grupos de recursos de AWS y no está seguro de cuántos nodos administrados tienen destino, limite el número de destinos que puede ejecutar el documento al mismo tiempo. Para ello, especifique un porcentaje.
+ En **Error threshold** (Umbral de errores), especifique cuándo desea parar la ejecución del comando en los demás nodos administrados después de que haya fallado en un número o un porcentaje de los nodos. Por ejemplo, si especifica tres errores, Systems Manager dejará de enviar el comando cuando se reciba el cuarto error. Los nodos administrados que estén procesando el comando todavía pueden enviar errores.
1. (Opcional) En **Opciones de salida**, para guardar la salida del comando en un archivo, seleccione el cuadro **Write command output to an S3 bucket**. Ingrese los nombres del bucket y del prefijo (carpeta) en los cuadros.
**nota**
Los permisos de S3 que conceden la capacidad de escribir datos en un bucket de S3 son los del perfil de instancia (para instancias de EC2) o rol de servicio de IAM (máquinas activadas de manera híbrida) asignados a la instancia, no los del usuario de IAM que realiza esta tarea. Para obtener más información, consulte [Configuración de permisos de instancia requeridos para Systems Manager](setup-instance-permissions.md) o [Creación de un rol de servicio de IAM para un entorno híbrido](hybrid-multicloud-service-role.md). Además, si el bucket de S3 especificado se encuentra en una Cuenta de AWS diferente, asegúrese de que el perfil de instancias o el rol de servicio de IAM asociado al nodo administrado tenga los permisos necesarios para escribir en ese bucket.
1. En la sección **Notificaciones de SNS**, seleccione la casilla de verificación **Habilitar notificaciones de SNS** si desea recibir notificaciones sobre el estado de ejecución de los comandos.
Para obtener más información acerca de la configuración de las notificaciones de Amazon SNS para Run Command, consulte [Cómo monitorear los cambios de estado de Systems Manager mediante las notificaciones de Amazon SNS](monitoring-sns-notifications.md).
1. Seleccione **Ejecutar**.
## Actualización de PowerShell con Run Command
En el siguiente procedimiento, se describe cómo actualizar PowerShell a la versión 5.1 en los nodos administrados de Windows Server 2012 y 2012 R2. El script proporcionado en este procedimiento descarga la actualización de Windows Management Framework (WMF) versión 5.1 e inicia la instalación de la actualización. El nodo se reinicia durante este proceso debido a que es necesario cuando se instala WMF 5.1. La descarga y la instalación de la actualización tardan aproximadamente cinco minutos en completarse.
**Para actualizar PowerShell con Run Command**
1. Abra la consola de AWS Systems Manager en [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. En el panel de navegación, elija **Run Command**.
1. Elija **Run command (Ejecutar comando)**.
1. En la lista **Command document** (Documento de Command), elija **`AWS-RunPowerShellScript`**.
1. En la sección **Commands** (Comandos), pegue los siguientes comandos para el sistema operativo.
------
#### [ Windows Server 2012 R2 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839516" -OutFile "Win8.1AndW2K12R2-KB3191564-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('Win8.1AndW2K12R2-KB3191564-x64.msu', '/quiet')
```
------
#### [ Windows Server 2012 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839513" -OutFile "W2K12-KB3191565-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('W2K12-KB3191565-x64.msu', '/quiet')
```
------
1. En la sección **Targets** (Destinos), para elegir los nodos administrados en los que desea ejecutar esta operación, especifique las etiquetas, seleccione las instancias o los dispositivos de borde manualmente o especifique un grupo de recursos.
**sugerencia**
Si un nodo administrado que espera ver no aparece en la lista, consulte [Solución de problemas de disponibilidad de nodos administrados](fleet-manager-troubleshooting-managed-nodes.md) para obtener consejos de solución de problemas.
1. En **Otros parámetros**:
+ En **Comentario**, ingrese la información acerca de este comando.
+ En **Tiempo de espera (segundos)**, especifique el número de segundos que tiene que esperar el sistema antes de indicar que se ha producido un error en la ejecución del comando general.
1. En **Rate control** (Control de velocidad):
+ En **Concurrency** (Simultaneidad), especifique un número o un porcentaje de los nodos administrados en los que desea ejecutar el comando al mismo tiempo.
**nota**
Si seleccionó los destinos mediante la especificación de etiquetas aplicadas a nodos administrados o de grupos de recursos de AWS y no está seguro de cuántos nodos administrados tienen destino, limite el número de destinos que puede ejecutar el documento al mismo tiempo. Para ello, especifique un porcentaje.
+ En **Error threshold** (Umbral de errores), especifique cuándo desea parar la ejecución del comando en los demás nodos administrados después de que haya fallado en un número o un porcentaje de los nodos. Por ejemplo, si especifica tres errores, Systems Manager dejará de enviar el comando cuando se reciba el cuarto error. Los nodos administrados que estén procesando el comando todavía pueden enviar errores.
1. (Opcional) En **Opciones de salida**, para guardar la salida del comando en un archivo, seleccione el cuadro **Write command output to an S3 bucket**. Ingrese los nombres del bucket y del prefijo (carpeta) en los cuadros.
**nota**
Los permisos de S3 que conceden la capacidad de escribir datos en un bucket de S3 son los del perfil de instancia (para instancias de EC2) o rol de servicio de IAM (máquinas activadas de manera híbrida) asignados a la instancia, no los del usuario de IAM que realiza esta tarea. Para obtener más información, consulte [Configuración de permisos de instancia requeridos para Systems Manager](setup-instance-permissions.md) o [Creación de un rol de servicio de IAM para un entorno híbrido](hybrid-multicloud-service-role.md). Además, si el bucket de S3 especificado se encuentra en una Cuenta de AWS diferente, asegúrese de que el perfil de instancias o el rol de servicio de IAM asociado al nodo administrado tenga los permisos necesarios para escribir en ese bucket.
1. En la sección **Notificaciones de SNS**, seleccione la casilla de verificación **Habilitar notificaciones de SNS** si desea recibir notificaciones sobre el estado de ejecución de los comandos.
Para obtener más información acerca de la configuración de las notificaciones de Amazon SNS para Run Command, consulte [Cómo monitorear los cambios de estado de Systems Manager mediante las notificaciones de Amazon SNS](monitoring-sns-notifications.md).
1. Seleccione **Ejecutar**.
Una vez reiniciado el nodo administrado y finalizada la instalación de la actualización, conéctese al nodo para confirmar que PowerShell se actualizó de forma correcta a la versión 5.1. Para verificar la versión de PowerShell en el nodo, abra PowerShell e ingrese `$PSVersionTable`. El valor de `PSVersion` en la tabla de salida mostrará 5.1 si la actualización se realizó de manera correcta.
Si el valor de `PSVersion` no es 5.1, por ejemplo, 3.0 o 4.0, revise los registros de **Setup** (Configuración) en el lector de eventos de **Windows Logs** (Registros de Windows). Estos registros indicarán por qué falló la instalación de la actualización.
# Tutorial: uso de la AWS CLI con Run Command
El siguiente ejemplo de explicación muestra cómo utilizar la AWS Command Line Interface (AWS CLI) para ver información acerca de los comandos y los parámetros de los comandos, de cómo ejecutar comandos y de cómo consultar el estado de dichos comandos.
**importante**
Solo los administradores de confianza deben utilizar los documentos de AWS Systems Manager preconfigurados que se muestran en este tema. Los comandos o los scripts especificados en los documentos de Systems Manager se ejecutan con permisos administrativos en los nodos administrados. Si un usuario tiene permiso para ejecutar cualquiera de los documentos de Systems Manager predefinidos (cualquier documento que empiece por `AWS-`), dicho usuario también tendrá acceso de administrador al nodo. Para todos los demás usuarios, debe crear documentos restrictivos y compartirlos con los usuarios específicos.
**Topics**
+ [Paso 1: introducción](#walkthrough-cli-settings)
+ [Paso 2: ejecutar scripts de shell para ver los detalles de los recursos](#walkthrough-cli-run-scripts)
+ [Paso 3: enviar comandos simples utilizando el documento `AWS-RunShellScript`](#walkthrough-cli-example-1)
+ [Paso 4: ejecutar una secuencia de comandos simple de Python mediante Run Command](#walkthrough-cli-example-2)
+ [Paso 5: ejecutar un script de Bash utilizando Run Command](#walkthrough-cli-example-3)
## Paso 1: introducción
Debe tener permisos de administrador en el nodo administrado que desea configurar o se le deben haber otorgado los permisos adecuados en AWS Identity and Access Management (IAM). También debe tener en cuenta que en este ejemplo se utiliza la región EE. UU. Este (Ohio) (us-east-2). Run Command está disponible en las Regiones de AWS que se indican en [Puntos de enlace de servicio de Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) en la *Referencia general de Amazon Web Services*. Para obtener más información, consulte [Configuración de nodos administrados para AWS Systems Manager](systems-manager-setting-up-nodes.md).
**Para ejecutar comandos utilizando la AWS CLI**
1. Si aún no lo ha hecho, instale y configure la AWS Command Line Interface (AWS CLI).
Para obtener más información, consulte [Instalación o actualización de la última versión de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Enumere todos los documentos disponibles.
Este comando enumera todos los documentos disponibles para su cuenta en función de los permisos de IAM.
```
aws ssm list-documents
```
1. Verifique si un nodo administrado está listo para recibir comandos.
La salida del siguiente comando muestra si los nodos administrados están en línea.
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--output text --query "InstanceInformationList[*]"
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--output text --query "InstanceInformationList[*]"
```
------
1. Ejecute el siguiente comando para ver los detalles sobre un nodo administrado en particular.
**nota**
Para ejecutar los comandos de esta explicación, debe sustituir los ID de la instancia y del comando. Para dispositivos de núcleo de AWS IoT Greengrass administrados, utilice el mi-*ID\$1number* para el ID de instancia. El ID de comando se devuelve como respuesta a **send-command**. Los ID de instancia están disponibles en Fleet Manager, una herramienta de AWS Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
## Paso 2: ejecutar scripts de shell para ver los detalles de los recursos
Si utiliza Run Command y el documento `AWS-RunShellScript`, puede ejecutar cualquier comando o script en un nodo administrado como si hubiera iniciado sesión de manera local.
**Ver la descripción y los parámetros disponibles**
Ejecute el siguiente comando para ver una descripción del documento JSON de Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "[Document.Name,Document.Description]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "[Document.Name,Document.Description]"
```
------
Ejecute el siguiente comando para ver los parámetros disponibles y los detalles sobre esos parámetros.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "Document.Parameters[*]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "Document.Parameters[*]"
```
------
## Paso 3: enviar comandos simples utilizando el documento `AWS-RunShellScript`
Ejecute el siguiente comando para obtener la información de la dirección IP de un nodo administrado de Linux.
Si se dirige a un nodo administrado de Windows Server, cambie el `document-name` a `AWS-RunPowerShellScript` y cambie el `command` de `ifconfig` a `ipconfig`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "IP config" \
--parameters commands=ifconfig \
--output text
```
------
#### [ Windows ]
```
aws ssm send-command ^
--instance-ids "instance-ID" ^
--document-name "AWS-RunShellScript" ^
--comment "IP config" ^
--parameters commands=ifconfig ^
--output text
```
------
**Obtener información de comandos con datos de respuesta**
El comando siguiente utiliza el ID de comando que ha devuelto el comando anterior para obtener los detalles y los datos de respuesta de la ejecución de comandos. El sistema devuelve los datos de respuesta si el comando se completó. Si la ejecución del comando muestra `"Pending"` o `"InProgress"`, ejecute este comando de nuevo para ver los datos de respuesta.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id $sh-command-id \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id $sh-command-id ^
--details
```
------
**Identificar usuario**
El siguiente comando muestra el usuario predeterminado que ejecuta los comandos.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux managed node" \
--parameters commands=whoami \
--output text \
--query "Command.CommandId")
```
------
**Obtener el estado del comando**
El comando siguiente utiliza el ID de comando para obtener el estado de la ejecución del comando en el nodo administrado. Este ejemplo utiliza el ID de comando devuelto en el comando anterior.
------
#### [ Linux & macOS ]
```
aws ssm list-commands \
--command-id "command-ID"
```
------
#### [ Windows ]
```
aws ssm list-commands ^
--command-id "command-ID"
```
------
**Obtener los detalles del comando**
El comando siguiente utiliza el ID de comando del comando anterior para obtener el estado de la ejecución del comando nodo por nodo.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id "command-ID" ^
--details
```
------
**Obtención de información de comando con los datos de respuesta de un nodo administrado concreto**
El siguiente comando devuelve la salida de la solicitud original `aws ssm send-command` para un nodo administrado concreto.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--instance-id instance-ID \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--instance-id instance-ID ^
--command-id "command-ID" ^
--details
```
------
**Mostrar versión de Python**
El siguiente comando devuelve la versión de Python que se ejecuta en un nodo.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters commands='python -V' \
--output text --query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Paso 4: ejecutar una secuencia de comandos simple de Python mediante Run Command
El siguiente comando ejecuta un simple script de Python “Hello World” mediante Run Command.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters '{"commands":["#!/usr/bin/python","print \"Hello World from python\""]}' \
--output text \
--query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Paso 5: ejecutar un script de Bash utilizando Run Command
En los ejemplos de esta sección, se muestra cómo ejecutar el siguiente script de bash utilizando Run Command.
Para ver ejemplos de cómo utilizar Run Command para ejecutar scripts almacenados en ubicaciones remotas, consulte [Ejecución de scripts desde Amazon S3](integration-s3.md) y [Ejecución de scripts desde GitHub](integration-remote-scripts.md).
```
#!/bin/bash
yum -y update
yum install -y ruby
cd /home/ec2-user
curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install
chmod +x ./install
./install auto
```
Este script instala el agente de AWS CodeDeploy en Amazon Linux y en las instancias de Red Hat Enterprise Linux (RHEL), tal como se describe en [Crear una instancia de Amazon EC2 para CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/instances-ec2-create.html) en la *Guía del usuario de AWS CodeDeploy*.
El script instala el agente de CodeDeploy desde un bucket de S3 administrado por AWS en la región Este de EE. UU. (Ohio) (us-east-2), `aws-codedeploy-us-east-2`.
**Ejecución de un script de bash en un comando de la AWS CLI**
En el ejemplo siguiente, se muestra cómo incluir el script de bash en un comando de la CLI mediante la opción `--parameters`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets '[{"Key":"InstanceIds","Values":["instance-id"]}]' \
--parameters '{"commands":["#!/bin/bash","yum -y update","yum install -y ruby","cd /home/ec2-user","curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install","chmod +x ./install","./install auto"]}'
```
------
**Ejecutar un script de bash en un archivo JSON**
En el ejemplo siguiente, el contenido del script de bash se almacena en un archivo JSON y el archivo se incluye en el comando mediante la opción `--cli-input-json`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets "Key=InstanceIds,Values=instance-id" \
--cli-input-json file://installCodeDeployAgent.json
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--targets "Key=InstanceIds,Values=instance-id" ^
--cli-input-json file://installCodeDeployAgent.json
```
------
El contenido del archivo `installCodeDeployAgent.json` al que se hace referencia se muestra en el ejemplo siguiente.
```
{
"Parameters": {
"commands": [
"#!/bin/bash",
"yum -y update",
"yum install -y ruby",
"cd /home/ec2-user",
"curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install",
"chmod +x ./install",
"./install auto"
]
}
}
```
# Tutorial: uso de la AWS Tools for Windows PowerShell con Run Command
Los siguientes ejemplos muestran cómo utilizar AWS Tools for Windows PowerShell para ver información sobre los comandos y los parámetros de comando, cómo ejecutar comandos y cómo consultar el estado de dichos comandos. Este tutorial incluye un ejemplo para cada uno de los documentos de AWS Systems Manager predefinidos.
**importante**
Solo los administradores de confianza deben tener permiso para utilizar los documentos preconfigurados de Systems Manager que se muestran en este tema. Los comandos o los scripts especificados en los documentos de Systems Manager se ejecutan con permisos administrativos en los nodos administrados. Si un usuario tiene permiso para ejecutar cualquiera de los documentos de Systems Manager predefinidos (cualquier documento que empiece con AWS), dicho usuario también tendrá acceso de administrador al nodo. Para todos los demás usuarios, debe crear documentos restrictivos y compartirlos con los usuarios específicos.
**Topics**
+ [Configurar las opciones de la sesión de AWS Tools for Windows PowerShell](#walkthrough-powershell-settings)
+ [Enumerar todos los documentos disponibles](#walkthrough-powershell-all-documents)
+ [Ejecutar comandos o scripts de PowerShell](#walkthrough-powershell-run-script)
+ [Instalar una aplicación utilizando el documento `AWS-InstallApplication`](#walkthrough-powershell-install-application)
+ [Instalar un módulo de PowerShell utilizando el documento JSON `AWS-InstallPowerShellModule`](#walkthrough-powershell-install-module)
+ [Unión de un nodo administrado a un dominio utilizando el documento JSON `AWS-JoinDirectoryServiceDomain`](#walkthrough-powershell-domain-join)
+ [Enviar métricas de Windows a los Registros de Amazon CloudWatch mediante el documento `AWS-ConfigureCloudWatch`](#walkthrough-powershell-windows-metrics)
+ [Activar o desactivar la actualización automática de Windows con el documento `AWS-ConfigureWindowsUpdate`](#walkthrough-powershell-enable-windows-update)
+ [Administrar las actualizaciones de Windows mediante Run Command](#walkthough-powershell-windows-updates)
## Configurar las opciones de la sesión de AWS Tools for Windows PowerShell
**Especificar sus credenciales**
Abra **Tools for Windows PowerShell** en su equipo local y ejecute el siguiente comando para especificar sus credenciales. Debe tener permisos de administrador en los nodos administrados que desea configurar o se le deben haber otorgado los permisos adecuados en AWS Identity and Access Management (IAM). Para obtener más información, consulte [Configuración de nodos administrados para AWS Systems Manager](systems-manager-setting-up-nodes.md).
```
Set-AWSCredentials –AccessKey key-name –SecretKey key-name
```
**Establezca una predeterminada. Región de AWS**
Ejecute el siguiente comando para establecer la región de la sesión de PowerShell. En el ejemplo, se utiliza la región Este de EE. UU. (Ohio) (us-east-2). Run Command está disponible en las Regiones de AWS que se indican en [Puntos de conexión de servicio de Systems Manager](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) en la *Referencia general de Amazon Web Services*.
```
Set-DefaultAWSRegion `
-Region us-east-2
```
## Enumerar todos los documentos disponibles
Este comando enumera todos los documentos disponibles para su cuenta.
```
Get-SSMDocumentList
```
## Ejecutar comandos o scripts de PowerShell
Si utiliza Run Command y el documento `AWS-RunPowerShell`, puede ejecutar cualquier comando o script en un nodo administrado como si hubiera iniciado sesión de manera local. Puede emitir comandos o ingresar una ruta a un script local para ejecutar el comando.
**nota**
Para obtener información acerca de cómo reiniciar los nodos administrados cuando se utiliza Run Command para llamar a scripts, consulte [Gestión de reinicios al ejecutar comandos](send-commands-reboot.md).
**Ver la descripción y los parámetros disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript"
```
**Ver más información sobre los parámetros**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript" | Select -ExpandProperty Parameters
```
### Enviar comandos utilizando el documento `AWS-RunPowerShellScript`
El siguiente comando muestra el contenido del directorio `"C:\Users"` y el contenido del directorio `"C:\"` en dos nodos administrados.
```
$runPSCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1", "instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'=@('dir C:\Users', 'dir C:\')}
```
**Obtener los detalles de la solicitud del comando**
El comando siguiente utiliza el `CommandId` para obtener el estado de la ejecución del comando en ambos nodos administrados. Este ejemplo utiliza el `CommandId` devuelto en el comando anterior.
```
Get-SSMCommand `
-CommandId $runPSCommand.CommandId
```
El estado del comando en este ejemplo puede ser Success, Pending o InProgress.
**Obtención de información de comandos por nodo administrado**
El comando siguiente utiliza el `CommandId` del comando anterior para obtener el estado de la ejecución del comando nodo por nodo.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId
```
**Obtención de información de comando con los datos de respuesta de un nodo administrado concreto**
El siguiente comando devuelve la salida del `Send-SSMCommand` original para un nodo administrado concreto.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Cancelar un comando
El siguiente comando cancela el comando `Send-SSMCommand` para el documento `AWS-RunPowerShellScript`.
```
$cancelCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1","instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'='Start-Sleep –Seconds 120; dir C:\'}
Stop-SSMCommand -CommandId $cancelCommand.CommandId
```
**Comprobar el estado del comando**
El comando siguiente comprueba el estado del comando `Cancel`.
```
Get-SSMCommand `
-CommandId $cancelCommand.CommandId
```
## Instalar una aplicación utilizando el documento `AWS-InstallApplication`
Si utiliza Run Command y el documento `AWS-InstallApplication`, puede instalar, reparar o desinstalar aplicaciones en nodos administrados. El comando requiere la ruta o dirección de un MSI.
**nota**
Para obtener información acerca de cómo reiniciar los nodos administrados cuando se utiliza Run Command para llamar a scripts, consulte [Gestión de reinicios al ejecutar comandos](send-commands-reboot.md).
**Ver la descripción y los parámetros disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication"
```
**Ver más información sobre los parámetros**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication" | Select -ExpandProperty Parameters
```
### Enviar comandos utilizando el documento `AWS-InstallApplication`
El siguiente comando instala una versión de Python en el nodo administrado en modo desatendido y registra la salida en un archivo de texto local de la unidad `C:`.
```
$installAppCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallApplication" `
-Parameter @{'source'='https://www.python.org/ftp/python/2.7.9/python-2.7.9.msi'; 'parameters'='/norestart /quiet /log c:\pythoninstall.txt'}
```
**Obtención de información de comandos por nodo administrado**
El comando siguiente utiliza el `CommandId` para obtener el estado de la ejecución del comando.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true
```
**Obtención de información de comando con los datos de respuesta de un nodo administrado concreto**
El siguiente comando devuelve el resultado de la instalación de Python.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
## Instalar un módulo de PowerShell utilizando el documento JSON `AWS-InstallPowerShellModule`
Puede utilizar Run Command para instalar módulos de PowerShell en nodos administrados. Para obtener más información acerca de los módulos de PowerShell, consulte [Módulos de Windows PowerShell](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_modules?view=powershell-6).
**Ver la descripción y los parámetros disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule"
```
**Ver más información sobre los parámetros**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule" | Select -ExpandProperty Parameters
```
### Instalar un módulo de PowerShell
El siguiente comando descarga el archivo EZOut.zip, lo instala y, a continuación, ejecuta un comando adicional para instalar el visor de XPS. Por último, la salida de este comando se carga en un bucket de S3 denominado “amzn-s3-demo-bucket”.
```
$installPSCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallPowerShellModule" `
-Parameter @{'source'='https://gallery.technet.microsoft.com/EZOut-33ae0fb7/file/110351/1/EZOut.zip';'commands'=@('Add-WindowsFeature -name XPS-Viewer -restart')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Obtención de información de comandos por nodo administrado**
El comando siguiente utiliza el `CommandId` para obtener el estado de la ejecución del comando.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true
```
**Obtención de información de comandos con los datos de respuesta del nodo administrado**
El siguiente comando devuelve el resultado del comando `Send-SSMCommand` original para el `CommandId` especificado.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Unión de un nodo administrado a un dominio utilizando el documento JSON `AWS-JoinDirectoryServiceDomain`
Si utiliza Run Command, puede unir rápidamente un nodo administrado a un dominio de AWS Directory Service. Antes de ejecutar este comando, [cree un directorio](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html). También le recomendamos obtener más información acerca de Directory Service. Para obtener más información, consulte la [Guía de administración de AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/).
Solo puede unir un nodo administrado a un dominio. No se puede eliminar un nodo de un dominio.
**nota**
Para obtener información acerca de los nodos administrados cuando se utiliza Run Command para llamar a scripts, consulte [Gestión de reinicios al ejecutar comandos](send-commands-reboot.md).
**Ver la descripción y los parámetros disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain"
```
**Ver más información sobre los parámetros**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain" | Select -ExpandProperty Parameters
```
### Unión de un nodo administrado a un dominio
El siguiente comando une un nodo administrado con el dominio Directory Service dado y carga cualquier salida generada en el bucket de ejemplo de Amazon Simple Storage Service (Amazon S3).
```
$domainJoinCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-JoinDirectoryServiceDomain" `
-Parameter @{'directoryId'='d-example01'; 'directoryName'='ssm.example.com'; 'dnsIpAddresses'=@('192.168.10.195', '192.168.20.97')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Obtención de información de comandos por nodo administrado**
El comando siguiente utiliza el `CommandId` para obtener el estado de la ejecución del comando.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true
```
**Obtención de información de comandos con los datos de respuesta del nodo administrado**
Este comando devuelve la salida del comando `Send-SSMCommand` original para el `CommandId` especificado.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Enviar métricas de Windows a los Registros de Amazon CloudWatch mediante el documento `AWS-ConfigureCloudWatch`
Puede enviar mensajes de Windows Server en los registros de aplicación, sistema, seguridad y Seguimiento de eventos para Windows (ETW) a los Registros de Amazon CloudWatch. Cuando se permite el registro por primera vez, Systems Manager envía todos los registros generados en un plazo de un (1) minuto a partir del momento en que empieza a cargar registros para los registros de aplicación, sistema, seguridad y ETW. No se incluyen los registros que se produjeron antes de este tiempo. Si desactiva el registro y después vuelve a activarlo, Systems Manager envía registros desde el momento en que dejó de hacerlo. En el caso de cualquier archivo de registros personalizado y registro de Internet Information Services (IIS), Systems Manager lee los archivos de registros desde el principio. Además, Systems Manager también puede enviar datos del contador de rendimiento a los Registros de CloudWatch.
Si con anterioridad activó la integración de CloudWatch en EC2Config, la configuración de Systems Manager anulará cualquier configuración almacenada de forma local en el nodo administrado en el archivo `C:\Program Files\Amazon\EC2ConfigService\Settings\AWS.EC2.Windows.CloudWatch.json`. Para obtener información sobre cómo se utiliza EC2Config para administrar los contadores de rendimiento y los registros en un solo nodo administrado, consulte [Recopilación de métricas y registros de instancias de Amazon EC2 y servidores locales con el agente de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html) en la *Guía del usuario de Amazon CloudWatch*.
**Ver la descripción y los parámetros disponibles**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch"
```
**Ver más información sobre los parámetros**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch" | Select -ExpandProperty Parameters
```
### Enviar registros de aplicación a CloudWatch
El siguiente comando configura el nodo administrado y mueve los registros de aplicaciones de Windows a CloudWatch.
```
$cloudWatchCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"ApplicationEventLog", "FullName":"AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"LogName":"Application", "Levels":"7"}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch", "Parameters":{"Region":"region", "LogGroup":"my-log-group", "LogStream":"instance-id"}}], "Flows":{"Flows":["ApplicationEventLog,CloudWatch"]}}}'}
```
**Obtención de información de comandos por nodo administrado**
El comando siguiente utiliza el `CommandId` para obtener el estado de la ejecución del comando.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true
```
**Obtención de información de comando con los datos de respuesta de un nodo administrado concreto**
El siguiente comando devuelve los resultados de la configuración de Amazon CloudWatch.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Enviar contadores de rendimiento a CloudWatch utilizando el documento `AWS-ConfigureCloudWatch`
El siguiente comando de demostración carga contadores de desempeño en CloudWatch. Para obtener más información, consulte la *[Guía del usuario de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
```
$cloudWatchMetricsCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"PerformanceCounter", "FullName":"AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"CategoryName":"Memory", "CounterName":"Available MBytes", "InstanceName":"", "MetricName":"AvailableMemory", "Unit":"Megabytes","DimensionName":"", "DimensionValue":""}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"AccessKey":"", "SecretKey":"","Region":"region", "NameSpace":"Windows-Default"}}], "Flows":{"Flows":["PerformanceCounter,CloudWatch"]}}}'}
```
## Activar o desactivar la actualización automática de Windows con el documento `AWS-ConfigureWindowsUpdate`
Si utiliza Run Command y el documento `AWS-ConfigureWindowsUpdate`, puede activar o desactivar las actualizaciones automáticas de Windows en los nodos administrados de Windows Server. Este comando configura el agente de Windows Update para que descargue e instale las actualizaciones de Windows el día y a la hora que usted especifique. Si una actualización requiere un reinicio, el nodo administrado se reiniciará automáticamente 15 minutos después de haber instalado las actualizaciones. Con este comando también puede configurar Windows Update para que verifique si hay actualizaciones, pero sin instalarlas. El documento `AWS-ConfigureWindowsUpdate` cuenta con soporte oficial en las versiones de Windows Server 2012 y posteriores.
**Ver la descripción y los parámetros disponibles**
```
Get-SSMDocumentDescription `
–Name "AWS-ConfigureWindowsUpdate"
```
**Ver más información sobre los parámetros**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureWindowsUpdate" | Select -ExpandProperty Parameters
```
### Activar la actualización automática de Windows
El siguiente comando configura Windows Update para que descargue e instale las actualizaciones automáticamente todos los días a las 10:00 h.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='InstallUpdatesAutomatically'; 'scheduledInstallDay'='Daily'; 'scheduledInstallTime'='22:00'}
```
**Ver el estado del comando para permitir la actualización automática de Windows**
El comando siguiente utiliza el `CommandId` para obtener el estado de la ejecución del comando para permitir la actualización automática de Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
### Desactivar la actualización automática de Windows
El comando siguiente reduce el nivel de notificación de Windows Update para que el sistema verifique si hay actualizaciones, pero no actualice automáticamente el nodo administrado.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='NeverCheckForUpdates'}
```
**Ver el estado del comando para desactivar la actualización automática de Windows**
El comando siguiente utiliza el `CommandId` para obtener el estado de la ejecución del comando para desactivar la actualización automática de Windows.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
## Administrar las actualizaciones de Windows mediante Run Command
Mediante el uso de Run Command y el documento `AWS-InstallWindowsUpdates`, puede administrar actualizaciones para nodos administrados de Windows Server. Este comando busca o instala las actualizaciones que faltan en los nodos administrados y, de forma opcional, se reinicia después de la instalación. También puede especificar las clasificaciones y los niveles de gravedad adecuados para las actualizaciones que se van a instalar en su entorno.
**nota**
Para obtener información acerca de cómo reiniciar los nodos administrados cuando se utiliza Run Command para llamar a scripts, consulte [Gestión de reinicios al ejecutar comandos](send-commands-reboot.md).
Los siguientes ejemplos muestran cómo realizar las tareas de administración de Windows Update especificadas.
### Buscar todas las actualizaciones de Windows que faltan
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Scan'}
```
### Instalar actualizaciones de Windows específicas
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'IncludeKbs'='kb-ID-1,kb-ID-2,kb-ID-3';'AllowReboot'='True'}
```
### Instalar las actualizaciones importantes de Windows que faltan
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'SeverityLevels'='Important';'AllowReboot'='True'}
```
### Instalar las actualizaciones de Windows que faltan con exclusiones específicas
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'ExcludeKbs'='kb-ID-1,kb-ID-2';'AllowReboot'='True'}
```
# Solución de problemas Systems Manager Run Command
Run Command, una herramienta de AWS Systems Manager, proporciona detalles de estado con la ejecución de cada comando. Para obtener más información acerca de los detalles de los estados del comando, consulte [Descripción de los estados del comando](monitor-commands.md). También puede utilizar la información de este tema como ayuda para solucionar problemas con Run Command.
**Topics**
+ [Faltan algunos de los nodos administrados](#where-are-instances)
+ [Un paso de mi script produjo un error, pero el estado general es “correcto”](#ts-exit-codes)
+ [SSM Agent no se ejecuta correctamente.](#ts-ssmagent-linux)
## Faltan algunos de los nodos administrados
En la página **Run a command** (Ejecutar un comando), después de elegir el documento de SSM que se va a ejecutar y de seleccionar **Manually selecting instances** (Seleccionar instancias manualmente) en la sección **Targets** (Destinos), se muestra una lista de los nodos administrados que puede elegir para ejecutar el comando.
Si un nodo administrado que espera ver no aparece en la lista, consulte [Solución de problemas de disponibilidad de nodos administrados](fleet-manager-troubleshooting-managed-nodes.md) para obtener consejos de solución de problemas.
Después de crear, activar o reiniciar un nodo administrado, instale Run Command en un nodo o adjunte un perfil de instancias de AWS Identity and Access Management (IAM) a un nodo. Pueden pasar algunos minutos hasta que el nodo administrado aparezca en la lista.
## Un paso de mi script produjo un error, pero el estado general es “correcto”
Mediante el uso de Run Command, puede definir cómo los scripts manejan los códigos de salida. De forma predeterminada, el código de salida del último comando ejecutado en un script se registra como el código de salida de todo el script. Sin embargo, puede incluir una instrucción condicional para salir del script si algún comando anterior al final produce un error. Para obtener más información y ejemplos, consulte [Especificación de códigos de salida en los comandos](run-command-handle-exit-status.md#command-exit-codes).
## SSM Agent no se ejecuta correctamente.
Si tiene dificultades cuando ejecute comandos con Run Command, es posible que haya algún problema con SSM Agent. Para obtener más información acerca de cómo investigar problemas con SSM Agent, consulte [Resolución de problemas de SSM Agent](troubleshooting-ssm-agent.md).