Automatice todo (creación de aplicaciones en la nube reales con Azure)

por Mike Wasson, Rick Anderson, Tom Dykstra

Descargar el proyecto de corrección de ti o descargar el libro electrónico

La creación de aplicaciones reales en la nube con el libro electrónico de Azure se basa en una presentación desarrollada por Scott Guthrie. Se explican 13 patrones y prácticas que pueden ayudarle a desarrollar correctamente aplicaciones web para la nube. Para obtener una introducción al libro electrónico, vea el primer capítulo.

Los tres primeros patrones que veremos en realidad se aplican a cualquier proyecto de desarrollo de software, pero especialmente a los proyectos en la nube. Este patrón trata sobre la automatización de tareas de desarrollo. Es un tema importante porque los procesos manuales son lentos y propensos a errores. automatizar tantas como sea posible ayuda a configurar un flujo de trabajo rápido, confiable y ágil. Es de gran importancia para el desarrollo en la nube, ya que puede automatizar fácilmente muchas tareas que son difíciles o imposibles de automatizar en un entorno local. Por ejemplo, puede configurar entornos de prueba completos, como nuevo servidor Web y máquinas virtuales de back-end, bases de datos, almacenamiento de blobs (almacenamiento de archivos), colas, etc.

Flujo de trabajo DevOps

Cada vez que oye el término "DevOps". El término desarrollado fuera de un reconocimiento que tiene que integrar tareas de desarrollo y operaciones para desarrollar software de forma eficaz. El tipo de flujo de trabajo que desea habilitar es aquél en el que puede desarrollar una aplicación, implementarla, aprender del uso de producción de ti, cambiarla en respuesta a lo que ha aprendido y repetir el ciclo de forma rápida y confiable.

Algunos equipos de desarrollo en la nube correctos se implementan varias veces al día en un entorno activo. El equipo de Azure usó para implementar una actualización principal cada 2-3 meses, pero ahora publica actualizaciones secundarias cada 2-3 días y versiones principales cada 2-3 semanas. Entrar en esa cadencia realmente le ayuda a responder a los comentarios de los clientes.

Para ello, tiene que habilitar un ciclo de desarrollo e implementación que sea repetible, confiable, predecible y que tenga un tiempo de ciclo inferior.

Flujo de trabajo DevOps

En otras palabras, el período de tiempo entre el momento en que se tiene una idea para una característica y el momento en que los clientes la usan y el envío de comentarios deben ser lo más cortos posible. Los tres primeros patrones: automatizar todo, el control de código fuente, la integración continua y la entrega, son todos los procedimientos recomendados que se recomiendan para habilitar ese tipo de proceso.

Scripts de administración de Azure

En la Introducción a este libro electrónico, vio la consola basada en Web, la portal de administración de Azure. El portal de administración de le permite supervisar y administrar todos los recursos que ha implementado en Azure. Es una forma sencilla de crear y eliminar servicios como aplicaciones web y máquinas virtuales, configurar esos servicios, supervisar el funcionamiento del servicio, etc. Es una herramienta excelente, pero su uso es un proceso manual. Si va a desarrollar una aplicación de producción de cualquier tamaño, especialmente en un entorno de equipo, se recomienda que pase por la interfaz de usuario del portal para aprender y explorar Azure y, a continuación, automatizar los procesos que va a realizar repetidamente.

Casi todo lo que puede hacer manualmente en el portal de administración o desde Visual Studio también se puede hacer mediante una llamada a la API de administración de REST. Puede escribir scripts mediante Windows PowerShell, o puede usar un marco de código abierto como chef o posiciónde trabajo. También puede usar la herramienta de línea de comandos bash en un entorno Mac o Linux. Azure tiene API de scripting para todos esos entornos diferentes y tiene una API de administración de .net en caso de que desee escribir código en lugar de script.

Para la aplicación Fix it, hemos creado algunos scripts de Windows PowerShell que automatizan los procesos de creación de un entorno de prueba e implementando el proyecto en ese entorno, y revisaremos parte del contenido de esos scripts.

Script de creación de entorno

El primer script que veremos se denomina New-AzureWebsiteEnv. PS1. Crea un entorno de Azure en el que puede implementar la aplicación Fix it para realizar pruebas. Las tareas principales que realiza este script son las siguientes:

  • Crear una aplicación web.
  • Cree una cuenta de almacenamiento. (Necesario para los blobs y las colas, como verá en los capítulos posteriores).
  • Cree un servidor de SQL Database y dos bases de datos: una base de datos de aplicación y una base de datos de pertenencia.
  • Almacene la configuración en Azure que la aplicación usará para acceder a la cuenta de almacenamiento y a las bases de datos.
  • Cree archivos de configuración que se usarán para automatizar la implementación.

Ejecute el script

Note

En esta parte del capítulo se muestran ejemplos de scripts y los comandos que se especifican para ejecutarlos. Esta es una demostración y no proporciona todo lo que necesita saber para ejecutar los scripts. Para obtener instrucciones paso a paso sobre cómo hacerlo, consulte Apéndice: aplicación de ejemplo de corrección.

Para ejecutar un script de PowerShell que administra los servicios de Azure, tiene que instalar la consola de Azure PowerShell y configurarla para que funcione con su suscripción de Azure. Una vez configurado, puede ejecutar el script de creación corregir entorno de TI con un comando como este:

.\New-AzureWebsiteEnv.ps1 -Name <websitename> -SqlDatabasePassword <password>

El parámetro Name especifica el nombre que se va a usar al crear la base de datos y las cuentas de almacenamiento, y el parámetro SqlDatabasePassword especifica la contraseña de la cuenta de administrador que se creará para SQL Database. Hay otros parámetros que puede usar para examinarlos más adelante.

Ventana de PowerShell

Una vez finalizado el script, puede ver en el portal de administración lo que se ha creado. Encontrará dos bases de datos:

Bases de datos

Una cuenta de almacenamiento:

Cuenta de almacenamiento

Y una aplicación web:

Sitio Web

En la pestaña configurar de la aplicación Web, puede ver que tiene la configuración de la cuenta de almacenamiento y las cadenas de conexión de SQL Database configuradas para la aplicación Fix it.

appSettings y connectionStrings

La carpeta Automation ahora también contiene un archivo <Websitename>. pubxml . Este archivo almacena la configuración que MSBuild usará para implementar la aplicación en el entorno de Azure que se acaba de crear. Por ejemplo:

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <WebPublishMethod>MSDeploy</WebPublishMethod>
    <SiteUrlToLaunchAfterPublish>http://fixitdemo.azurewebsites.net</SiteUrlToLaunchAfterPublish>
    <ExcludeApp_Data>False</ExcludeApp_Data>
    <MSDeployServiceURL>waws-prod-bay-003.publish.azurewebsites.windows.net:443</MSDeployServiceURL>
    <DeployIisAppPath>fixitdemo</DeployIisAppPath>
    <RemoteSitePhysicalPath />
    <SkipExtraFilesOnServer>True</SkipExtraFilesOnServer>
    <MSDeployPublishMethod>WMSVC</MSDeployPublishMethod>
    <EnableMSDeployBackup>True</EnableMSDeployBackup>
    <UserName>$fixitdemo</UserName>
    <PublishDatabaseSettings></PublishDatabaseSettings>
  </PropertyGroup>
</Project>

Como puede ver, el script ha creado un entorno de prueba completo y todo el proceso se realiza en unos 90 segundos.

Si otra persona de su equipo quiere crear un entorno de prueba, solo puede ejecutar el script. No solo es rápido, sino que también pueden estar seguros de que usan un entorno idéntico al que está usando. No podía estar tan seguro de que si todos estuvieran configurando elementos manualmente mediante la interfaz de usuario del portal de administración.

Un vistazo a los scripts

En realidad, hay tres scripts que realizan este trabajo. Se llama a una desde la línea de comandos y se usan automáticamente las otras dos para realizar algunas de las tareas:

  • New-AzureWebSiteEnv. PS1 es el script principal.

    • New-AzureStorage. PS1 crea la cuenta de almacenamiento.
    • New-AzureSql. PS1 crea las bases de datos.

Parámetros en el script principal

El script principal, New-AzureWebSiteEnv. PS1, define varios parámetros:

[CmdletBinding(PositionalBinding=$True)]
Param(
    [Parameter(Mandatory = $true)]
    [ValidatePattern("^[a-z0-9]*$")]
    [String]$Name,                             
    [String]$Location = "West US",             
    [String]$SqlDatabaseUserName = "dbuser",   
    [String]$SqlDatabasePassword,              
    [String]$StartIPAddress,                   
    [String]$EndIPAddress                      
    )

Se requieren dos parámetros:

  • Nombre de la aplicación web que crea el script. (También se utiliza para la dirección URL: <name>.azurewebsites.net).
  • La contraseña para el nuevo usuario administrativo del servidor de bases de datos que crea el script.

Los parámetros opcionales le permiten especificar la ubicación del centro de datos (el valor predeterminado es "oeste de EE. UU."), el nombre del administrador del servidor de bases de datos (el valor predeterminado es "dbUser") y una regla de Firewall para el servidor de base de datos.

Creación de la aplicación web

Lo primero que hace el script es crear la aplicación Web mediante una llamada al cmdlet New-AzureWebsite, pasándole los valores de parámetro de ubicación y nombre de la aplicación web:

# Create a new website
$website = New-AzureWebsite -Name $Name -Location $Location -Verbose

Creación de la cuenta de almacenamiento

Después, el script principal ejecuta el script New-AzureStorage. PS1 , especificando " <Websitename> Storage" para el nombre de la cuenta de almacenamiento y la misma ubicación del centro de datos que la aplicación Web.

$storageAccountName = $Name + "storage"
 
$storage = $scriptPath\New-AzureStorage.ps1" -Name $storageAccountName -Location $Location

New-AzureStorage. PS1 llama al cmdlet New-AzureStorageAccount para crear la cuenta de almacenamiento y devuelve los valores de nombre de cuenta y clave de acceso. La aplicación necesitará estos valores para tener acceso a los blobs y las colas de la cuenta de almacenamiento.

# Create a new storage account
New-AzureStorageAccount -StorageAccountName $Name -Location $Location -Verbose
 
# Get the access key of the storage account
$key = Get-AzureStorageKey -StorageAccountName $Name
 
# Generate the connection string of the storage account
$connectionString = "BlobEndpoint=http://$Name.blob.core.windows.net/;QueueEndpoint=http://$Name.queue.core.windows.net/;TableEndpoint=http://$Name.table.core.windows.net/;AccountName=$Name;AccountKey=$primaryKey"
 
#Return a hashtable of storage account values
Return @{AccountName = $Name; AccessKey = $key.Primary; ConnectionString = $connectionString}

Es posible que no siempre quiera crear una nueva cuenta de almacenamiento. podría mejorar el script agregando un parámetro que, opcionalmente, lo dirija para usar una cuenta de almacenamiento existente.

Crear las bases de datos

Después, el script principal ejecuta el script de creación de la base de datos, New-AzureSql. PS1, después de configurar los nombres predeterminados de las reglas de firewall y de base de datos:

$sqlAppDatabaseName = "appdb"
$sqlMemberDatabaseName = "memberdb"
$sqlDatabaseServerFirewallRuleName = $Name + "rule"
# Create a SQL Azure database server, app and member databases
$sql = $scriptPath\New-AzureSql.ps1 `
    -AppDatabaseName $sqlAppDatabaseName `
    -MemberDatabaseName $sqlMemberDatabaseName `
    -UserName $SqlDatabaseUserName `
    -Password $SqlDatabasePassword `
    -FirewallRuleName $sqlDatabaseServerFirewallRuleName `
    -StartIPAddress $StartIPAddress `
    -EndIPAddress $EndIPAddress `
    -Location $Location

El script de creación de base de datos recupera la dirección IP del equipo de desarrollo y establece una regla de Firewall para que el equipo de desarrollo pueda conectarse al servidor y administrarlo. El script de creación de la base de datos pasa por varios pasos para configurar las bases de datos:

  • Crea el servidor mediante el cmdlet New-AzureSqlDatabaseServer.

    $databaseServer = New-AzureSqlDatabaseServer -AdministratorLogin $UserName -AdministratorLoginPassword $Password -Location $Location
    
  • Crea reglas de Firewall para permitir que el equipo de desarrollo administre el servidor y permitir que la aplicación web se conecte a él.

    # Create a SQL Azure database server firewall rule for the IP address of the machine in which this script will run
    # This will also whitelist all the Azure IP so that the website can access the database server
    New-AzureSqlDatabaseServerFirewallRule -ServerName $databaseServerName -RuleName $FirewallRuleName -StartIpAddress $StartIPAddress 
    -EndIpAddress $EndIPAddress -Verbose
    New-AzureSqlDatabaseServerFirewallRule -ServerName $databaseServer.ServerName -AllowAllAzureServices 
    -RuleName "AllowAllAzureIP" -Verbose
    
  • Crea un contexto de base de datos que incluye el nombre del servidor y las credenciales, mediante el cmdlet New-AzureSqlDatabaseServerContext.

    # Create a database context which includes the server name and credential
    # These are all local operations. No API call to Azure
    $credential = New-PSCredentialFromPlainText -UserName $UserName -Password $Password
    $context = New-AzureSqlDatabaseServerContext -ServerName $databaseServer.ServerName -Credential $credential
    

    New-PSCredentialFromPlainText es una función del script que llama al cmdlet ConvertTo-SecureString para cifrar la contraseña y devuelve un objeto PSCredential, el mismo tipo que devuelve el cmdlet Get-Credential.

  • Crea la base de datos de la aplicación y la base de datos de pertenencia mediante el cmdlet New-AzureSqlDatabase.

    # Use the database context to create app database
    New-AzureSqlDatabase -DatabaseName $AppDatabaseName -Context $context -Verbose
     
    # Use the database context to create member database
    New-AzureSqlDatabase -DatabaseName $MemberDatabaseName -Context $context -Verbose
    
  • Llama a una función definida localmente para crear una cadena de conexión para cada base de datos. La aplicación usará estas cadenas de conexión para tener acceso a las bases de datos.

    $appDatabaseConnectionString = Get-SQLAzureDatabaseConnectionString -DatabaseServerName $databaseServerName -DatabaseName $AppDatabaseName -UserName $UserName -Password $Password
    $memberDatabaseConnectionString = Get-SQLAzureDatabaseConnectionString -DatabaseServerName $databaseServerName -DatabaseName $MemberDatabaseName -UserName $UserName -Password $Password
    

    Get-SQLAzureDatabaseConnectionString es una función definida en el script que crea la cadena de conexión a partir de los valores de parámetro que se le proporcionan.

    Function Get-SQLAzureDatabaseConnectionString
    {
        Param(
            [String]$DatabaseServerName,
            [String]$DatabaseName,
            [String]$UserName,
            [String]$Password
        )
    
        Return "Server=tcp:$DatabaseServerName.database.windows.net,1433;Database=$DatabaseName;User ID=$UserName@$DatabaseServerName;Password=$Password;Trusted_Connection=False;Encrypt=True;Connection Timeout=30;"
    }
    
  • Devuelve una tabla hash con el nombre del servidor de bases de datos y las cadenas de conexión.

    Return @{ `
        Server = $databaseServer.ServerName; UserName = $UserName; Password = $Password; `
        AppDatabase = @{Name = $AppDatabaseName; ConnectionString = $appDatabaseConnectionString}; `
        MemberDatabase = @{Name = $MemberDatabaseName; ConnectionString = $memberDatabaseConnectionString} `
    }
    

La aplicación Fix it usa bases de datos de pertenencia y de aplicación independientes. También es posible colocar datos de pertenencia y de aplicación en una sola base de datos.

Almacenar la configuración de la aplicación y las cadenas de conexión

Azure tiene una característica que permite almacenar la configuración y las cadenas de conexión que invalidan automáticamente lo que se devuelve a la aplicación cuando intenta leer las colecciones appSettings o connectionStrings en el archivo Web. config. Se trata de una alternativa a la aplicación de transformaciones Web. config al implementar. Para obtener más información, consulte almacenamiento de datos confidenciales en Azure más adelante en este libro electrónico.

El script de creación de entorno almacena en Azure todos los valores appSettings y connectionStrings que la aplicación necesita para acceder a la cuenta de almacenamiento y a las bases de datos cuando se ejecuta en Azure.

# Configure app settings for storage account and New Relic
$appSettings = @{ `
    "StorageAccountName" = $storageAccountName; `
    "StorageAccountAccessKey" = $storage.AccessKey; `
    "COR_ENABLE_PROFILING" = "1"; `
    "COR_PROFILER" = "{71DA0A04-7777-4EC6-9643-7D28B46A8A41}"; `
    "COR_PROFILER_PATH" = "C:\Home\site\wwwroot\newrelic\NewRelic.Profiler.dll"; `
    "NEWRELIC_HOME" = "C:\Home\site\wwwroot\newrelic" `
}
# Configure connection strings for appdb and ASP.NET member db
$connectionStrings = ( `
    @{Name = $sqlAppDatabaseName; Type = "SQLAzure"; ConnectionString = $sql.AppDatabase.ConnectionString}, `
    @{Name = "DefaultConnection"; Type = "SQLAzure"; ConnectionString = $sql.MemberDatabase.ConnectionString}
)
# Add the connection string and storage account name/key to the website
Set-AzureWebsite -Name $Name -AppSettings $appSettings -ConnectionStrings $connectionStrings

New Relic es un marco de telemetría que se muestra en el capítulo de supervisión y telemetría . El script de creación de entorno también reinicia la aplicación web para asegurarse de que recoge la nueva configuración de Relic.

# Restart the website to let New Relic hook kick in
Restart-AzureWebsite -Name $websiteName

Preparación para la implementación

Al final del proceso, el script de creación del entorno llama a dos funciones para crear archivos que usará el script de implementación.

Una de estas funciones crea un perfil de publicación (<websitename>archivo. pubxml ). El código llama a la API de REST de Azure para obtener la configuración de publicación y guarda la información en un archivo . publishsettings . A continuación, usa la información de ese archivo junto con un archivo de plantilla (pubxml. template) para crear el archivo . pubxml que contiene el perfil de publicación. En este proceso de dos pasos se simula lo que hace en Visual Studio: descargar un archivo . publishsettings e importarlo para crear un perfil de publicación.

La otra función usa otro archivo de plantilla (website-Environment. template) para crear un archivo website-Environment. XML que contenga la configuración que el script de implementación usará junto con el archivo . pubxml .

Solución de problemas y control de errores

Los scripts son similares a los programas: pueden producir errores y, cuando se desea saber todo lo que se puede hacer sobre el error y lo que lo causó. Por esta razón, el script de creación del entorno cambia el valor de la variable VerbosePreference de SilentlyContinue a Continue para que se muestren todos los mensajes detallados. También cambia el valor de la variable ErrorActionPreference de Continue a Stop, de modo que el script se detenga incluso cuando detecte errores de no terminación:

# Set the output level to verbose and make the script stop on error
$VerbosePreference = "Continue"
$ErrorActionPreference = "Stop"

Antes de realizar cualquier trabajo, el script almacena la hora de inicio para que pueda calcular el tiempo transcurrido cuando se hace:

# Mark the start time of the script execution
$startTime = Get-Date

Una vez completado el trabajo, el script muestra el tiempo transcurrido:

# Mark the finish time of the script execution
$finishTime = Get-Date
# Output the time consumed in seconds
Write-Output ("Total time used (seconds): {0}" -f ($finishTime - $startTime).TotalSeconds)

Y para cada operación de clave el script escribe mensajes detallados, por ejemplo:

Write-Verbose "[Start] creating $websiteName website in $Location location"
$website = New-AzureWebsite -Name $websiteName -Location $Location -Verbose
Write-Verbose "[Finish] creating $websiteName website in $Location location"

Script de implementación

Qué hace el script New-AzureWebsiteEnv. PS1 para la creación del entorno, el script Publish-AzureWebsite. PS1 hace para la implementación de la aplicación.

El script de implementación obtiene el nombre de la aplicación web del archivo website-Environment. XML creado por el script de creación del entorno.

[Xml]$envXml = Get-Content "$scriptPath\website-environment.xml"
$websiteName = $envXml.environment.name

Obtiene la contraseña de usuario de implementación del archivo . publishsettings :

[Xml]$xml = Get-Content $scriptPath\$websiteName.publishsettings 
$password = $xml.publishData.publishProfile.userPWD[0]
$publishXmlFile = Join-Path $scriptPath -ChildPath ($websiteName + ".pubxml")

Ejecuta el comando de msbuild que compila e implementa el proyecto:

& "$env:windir\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe" $ProjectFile `
    /p:VisualStudioVersion=12.0 `
    /p:DeployOnBuild=true `
    /p:PublishProfile=$publishXmlFile `
    /p:Password=$password

Y si ha especificado el parámetro Launch en la línea de comandos, llama al cmdlet Show-AzureWebsite para abrir el explorador predeterminado en la dirección URL del sitio Web.

If ($Launch)
{
    Show-AzureWebsite -Name $websiteName
}

Puede ejecutar el script de implementación con un comando como este:

.\Publish-AzureWebsite.ps1 ..\MyFixIt\MyFixIt.csproj -Launch

Cuando haya terminado, el explorador se abrirá con el sitio que se ejecuta en la nube en la <websitename>.azurewebsites.net dirección URL.

Corregir la aplicación de ti implementada en Windows Azure

Resumen

Con estos scripts puede estar seguro de que los mismos pasos siempre se ejecutarán en el mismo orden con las mismas opciones. Esto ayuda a garantizar que todos los desarrolladores del equipo no pierdan nada o dispongan de nada o implementen algo personalizado en su propio equipo que realmente no funcione de la misma manera en el entorno de otro miembro del equipo o en producción.

De forma similar, puede automatizar la mayoría de las funciones de administración de Azure que puede realizar en el portal de administración, mediante la API de REST, scripts de Windows PowerShell, una API de lenguaje .NET o una utilidad bash que se puede ejecutar en Linux o Mac.

En el siguiente capítulo veremos el código fuente y explicaremos por qué es importante incluir los scripts en el repositorio de código fuente.

Recursos