comandos - Cómo ejecutar programáticamente/de forma remota un programa en la instancia de Windows EC2

amazon linux ami comandos

Question

Me gustaría iniciar una instancia de Windows EC2, cargar un archivo ejecutable y ejecutarlo (todo de forma automática , esto es importante)

Hasta ahora pude lanzar la instancia de Windows EC2 mediante programación y obtener sus parámetros (contraseña / IP), ahora me gustaría encontrar una forma de cargar este ejecutable ( desde mi máquina Windows o desde mi otra instancia de Linux EC2 ) y ejecutarlo .

Pensé en lanzar una conexión RDP y usar un software de macros para cargar y ejecutar el archivo, pero en base a experiencias anteriores, este es un enfoque pobre / frágil, por decir lo menos.

También pensé en cargar este EXE en un servidor, luego hacer algo como esto en Windows:

wget http://www.domain.com/my-file.exe

Excepto que Windows no tiene wget!

Entonces, mi pregunta es: ¿hay una manera de cargar y ejecutar un EXEcutable mediante programación en la instancia de Windows EC2?

Answer 1

El comando ec2-run-instances tiene dos argumentos adicionales que se pueden usar al ejecutar el comando. Tanto el comando de user-data user-data-file realizan la misma tarea solo que se leen desde diferentes entradas. Cuando utilice este argumento, el contenido de los datos de usuario se cargará en un URI alojado en Amazon http://169.254.169.254/1.0/user-data solo disponible para la instancia que se lanzó.

La forma normal de hacer esto en el entorno de Linux sería cargar un script de shell en la instancia para descargar el archivo ejecutable, su archivo de datos de usuario podría tener este aspecto ...

#! /bin/bash
wget http://www.domain.com/my-file.exe

En Windows no hay un servicio predeterminado instalado para ejecutar el archivo de datos de usuario cuando se inicia la instancia, pero hay un proyecto de código abierto CloudInit.NET que simula el mismo proceso pero con un script powershell. Los únicos requisitos son .NET 4.0 y CloudInit.NET. Una vez instalado, ejecutará el archivo de datos de usuario cuando se inicie la instancia. Es muy fácil descargar un archivo y ejecutarlo con un script de powershell.

!# /powershell/
$wc = New-Object System.Net.WebClient
$wc.DownloadFile("http://www.domain.com/my-file.exe", "C:/my-file.exe");
& ''C:/my-file.exe''

Answer 2

Esto suena como un caso de uso perfecto de CloudFormation. He creado una plantilla que demuestra. Para usarlo, ponga su ejecutable en un cubo de S3 y cree una nueva pila de CloudFormation con la siguiente plantilla. Descargará su ejecutable de S3 y lo ejecutará. Nota: la plantilla hace uso de AMIs especiales con CloudFormationScripts incorporados.

{
    "AWSTemplateFormatVersion" : "2010-09-09",
    "Description" : "Spot Autoscaling for installing and running Windows Services.",
    "Parameters" : {
        "InstanceType" : {
            "Description" : "WebServer EC2 instance type",
            "Type" : "String",
            "Default" : "m1.small",
            "AllowedValues" : ["t1.micro", "m1.small", "m1.medium", "m1.large", "m1.xlarge", "m2.xlarge", "m2.2xlarge", "m2.4xlarge", "c1.medium", "c1.xlarge", "cc1.4xlarge", "cc2.8xlarge", "cg1.4xlarge"],
            "ConstraintDescription" : "must be a valid EC2 instance type."
        },
        "KeyName" : {
            "Description" : "The EC2 Key Pair to get Admin password to Instance.",
            "Type" : "String"
        },
        "DeployS3Bucket" : {
            "Description" : "The S3 Bucket where deploy files are stored",
            "Type" : "String"
        },
        "DeployS3Key" : {
            "Description" : "The exe file that runs on startup",
            "Type" : "String"
        }
    },
    "Mappings" : {
        "RegionToAMIMap" : {
            "us-east-1" : {
                "AMI" : "ami-60b90609"
            },
            "us-west-1" : {
                "AMI" : "ami-5bd6f11e"
            },
            "eu-west-1" : {
                "AMI" : "ami-07151573"
            },
            "ap-southeast-1" : {
                "AMI" : "ami-6ab5f538"
            },
            "ap-northeast-1" : {
                "AMI" : "ami-424ff043"
            }
        }
    },
    "Resources" : {
        "IAMUser" : {
            "Type" : "AWS::IAM::User",
            "Properties" : {
                "Path" : "/",
                "Policies" : [{
                    "PolicyName" : "root",
                    "PolicyDocument" : {
                        "Statement" : [{
                            "Effect" : "Allow",
                            "Action" : "*",
                            "Resource" : "*"
                        }]
                    }
                }]
            }
        },
        "IAMUserAccessKey" : {
            "Type" : "AWS::IAM::AccessKey",
            "Properties" : {
                "UserName" : {
                    "Ref" : "IAMUser"
                }
            }
        },
        "SecurityGroup" : {
            "Type" : "AWS::EC2::SecurityGroup",
            "Properties" : {
                "GroupDescription" : "Enable RDP",
                "SecurityGroupIngress" : [{
                    "IpProtocol" : "tcp",
                    "FromPort" : "3389",
                    "ToPort" : "3389",
                    "CidrIp" : "0.0.0.0/0"
                }]
            }
        },
        "RunExecutable" : {
            "Type" : "AWS::EC2::Instance",
            "Metadata" : {
                "AWS::CloudFormation::Init" : {
                    "config" : {
                        "files" : {
                            "c://ToRun//executable.exe" : {
                                "source" : {
                                    "Fn::Join" : ["/", ["http://s3.amazonaws.com", {
                                        "Ref" : "DeployS3Bucket"
                                    }, {
                                        "Ref" : "DeployS3Key"
                                    }]]
                                },
                                "authentication" : "S3AccessCreds"
                            }
                        },
                        "commands" : {
                            "1-run-executable" : {
                                "command" : "c://ToRun//executable.exe"
                            }
                        }
                    }
                },
                "AWS::CloudFormation::Authentication" : {
                    "S3AccessCreds" : {
                        "type" : "S3",
                        "accessKeyId" : {
                            "Ref" : "IAMUserAccessKey"
                        },
                        "secretKey" : {
                            "Fn::GetAtt" : ["IAMUserAccessKey", "SecretAccessKey"]
                        },
                        "buckets" : [{
                            "Ref" : "DeployS3Bucket"
                        }]
                    }
                }
            },
            "Properties" : {
                "KeyName" : {
                    "Ref" : "KeyName"
                },
                "ImageId" : {
                    "Fn::FindInMap" : ["RegionToAMIMap", {
                        "Ref" : "AWS::Region"
                    }, "AMI"]
                },
                "SecurityGroups" : [{
                    "Ref" : "SecurityGroup"
                }],
                "InstanceType" : {
                    "Ref" : "InstanceType"
                },
                "UserData" : {
                    "Fn::Base64" : {
                        "Fn::Join" : ["", ["<script>/n", "cfn-init.exe -v -s ", {
                            "Ref" : "AWS::StackName"
                        }, " -r RunExecutable ", " --access-key ", {
                            "Ref" : "IAMUserAccessKey"
                        }, " --secret-key ", {
                            "Fn::GetAtt" : ["IAMUserAccessKey", "SecretAccessKey"]
                        }, "/n", "</script>"]]
                    }
                }
            }
        }
    },
    "Outputs" : {}
}

Answer 3

Hice una automatización similar para AWS para la implementación empresarial en 2011. La formación de la nube de Amazon y las operaciones estaban aún en construcción. Sin embargo, habíamos realizado con éxito la automatización de la implementación utilizando dotnet para las plataformas Linux y Windows. El modelo powershell y ftp se descartó Debido a que era un entorno empresarial y existía una restricción de puertos. A continuación se presentan los enfoques que he utilizado.

Nota: Esta fue la aplicación web asp.net

Para la implementación de Linux.

Utilizamos un proyecto de código abierto llamado sharpshell (sharpSSH). Esta es la aplicación c # que simula la comunicación de shell entre Windows y Linux. Solo es necesario proporcionar la dirección de destino y la clave de seguridad para conectarse. Personalizamos la aplicación alrededor de nuestro requerimiento.

Para ventanas

Dicho esto, la API de formación de la nube aún no está disponible y la documentación disponible por AWS es menor. Utilizamos una solución alternativa, un enfoque de servicio web. Se creó un servicio web que básicamente carga un archivo al servidor y lo implementa. Con este servidor web alojado en un servidor Windows de Amazaon. Se creó una imagen base de este y un certificado. Finalmente, una nueva instancia creada a partir de esta imagen tendría servicios web alojados a los que se podría llamar para cargar el paquete de implementación e instalarlo en ese sistema.

A pesar de los principios anteriores no eran a prueba de tontos y tenían menos control. logramos la funcionalidad de implementación directa multiplataforma de Windows a Linux sin utilizar depósitos de S3 o powershell.

Por favor, hágamelo saber si necesita alguna aclaración.

¡Aclamaciones! Charles

Answer 4

Puedes manejar esto de 2 maneras,

• Usando winscp en el programa de Windows SFTP.

  Para acceder a su servidor de Amazon utilizando SFTP en Windows, descargue una aplicación de Windows SFTP. Usando WinSCP establecerá una sesión SFTP con su servidor. WinSCP ofrece algunas características interesantes que facilitan el trabajo con su servidor EC2. Por ejemplo, un comando en la barra de botones abre una sesión de terminal PuTTY SSH con las mismas credenciales que usó para su sesión SFTP. (También puede iniciar una sesión de PuTTY haciendo clic en CTRL + P).

• Obtenga un cucharón S3 y monte en todas sus instancias de Windows y Linux EC2. Debería poder cargar y descargar los archivos a S3 bucket desde su estación de trabajo, a la que pueden acceder sus instancias.

Answer 5

Un enfoque alternativo es usar Windows PowerShell y WinRM, que permite la ejecución remota, un poco como ssh en Linux.

Aquí hay una muestra de un script de powershell que puede ejecutar en el cliente para ejecutar un script de forma remota (tomado de: https://github.com/CloudifySource/cloudify/blob/master/esc/src/main/resources/clouds/ec2-win/upload/bootstrap-client.ps1 ):

param ([string]$target, [string]$username, [string]$password, [string]$command)

$ErrorActionPreference="Stop"

# Set up the password
$securePassword = ConvertTo-SecureString -AsPlainText -Force $password
$cred = New-Object System.Management.Automation.PSCredential $username, $securePassword

Write-Host "Connecting to management service of $target"
Connect-WSMan -Credential $cred $target 

set-item WSMan:/$target/Client/TrustedHosts -Value * -Force
set-item WSMan:/$target/Shell/MaxMemoryPerShellMB -Value 0 -Force

Write-Host Invoking command on Remote host $target
Invoke-Command -ComputerName $target -Credential $cred  -ScriptBlock {  
    Invoke-Expression $args[0]
} -ArgumentList $command
Write-Host "Command finished"

Puede ejecutar este comando desde su propio script con el siguiente comando:

powershell.exe -inputformat none -File PATH_TO_SCRIPT -target TARGET_IP -password PASSWORD -username USERNAME -command COMMAND_TO_EXECUTE

Probablemente debería citar sus cadenas, especialmente la contraseña y el comando, ya que estos generalmente tendrán caracteres especiales que PowerShell puede interpretar como otra cosa.

El servicio WinRM está activado de forma predeterminada en las AMI de EC2 Amazon Windows. Todo lo que necesita hacer es abrir el puerto 5985 (el puerto WinRM) en su grupo de seguridad.

Finalmente, si nunca ha usado el control remoto de powershell en su máquina cliente antes, hay un par de comandos que debe ejecutar para configurarlo (solo necesita hacerlo una vez):

set-item WSMan:/localhost/Client/TrustedHosts -Value * -Force
set-item WSMan:/localhost/Shell/MaxMemoryPerShellMB -Value 0 -Force
Enable-PSRemoting
Set-ExecutionPolicy unrestricted

Asegúrese de ejecutar estos como un administrador.