Tutorial: Compilación de una aplicación de ASP.NET Core y Azure SQL Database en Azure App Service

En este tutorial, aprenderá a:

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Prerrequisitos

Para completar este tutorial:

• Instalación de Git
• Instale el SDK de .NET 5.0 más reciente.

• Use el entorno de Bash en Azure Cloud Shell.

  

• Si lo prefiere, instale la CLI de Azure para ejecutar sus comandos de referencia.

  • Si usa una instalación local, inicie sesión en la CLI de Azure mediante el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Inicio de sesión con la CLI de Azure.

  • Cuando se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información sobre las extensiones, consulte Uso de extensiones con la CLI de Azure.

  • Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para realizar la actualización a la versión más reciente, ejecute az upgrade.

Creación de una aplicación ASP.NET Core local

En este paso, configurará el proyecto ASP.NET Core local.

Clonación de la aplicación de ejemplo

1. En la ventana del terminal, use cd para cambiar a un directorio de trabajo.

2. Ejecute los comandos siguientes para clonar el repositorio de ejemplo y cambiar a su raíz.

   git clone https://github.com/azure-samples/dotnetcore-sqldb-tutorial
   cd dotnetcore-sqldb-tutorial
   

   El proyecto de ejemplo contiene una aplicación básica CRUD (crear, leer, actualizar, eliminar) que usa Entity Framework Core.

3. Asegúrese de que la rama predeterminada sea main.

   git branch -m main
   

   Sugerencia

   App Service no exige el cambio de nombre de rama. Sin embargo, dado que muchos repositorios cambian su rama predeterminada a main (consulte Cambio de la rama de implementación), en este tutorial también se muestra cómo implementar un repositorio desde main.

Ejecución de la aplicación

1. Ejecute los comandos siguientes para instalar los paquetes necesarios, ejecutar las migraciones de bases de datos e iniciar la aplicación.

   dotnet tool install -g dotnet-ef
   dotnet ef database update
   dotnet run
   

2. Vaya a http://localhost:5000 en un explorador. Seleccione el vínculo Crear nuevo y cree un par de elementos de tareas pendientes.

   

3. Para detener ASP.NET Core en cualquier momento, presione Ctrl+C en el terminal.

Creación de una instancia de SQL Database de producción

En este paso, creará una instancia de SQL Database en Azure. Cuando la aplicación se implementa en Azure, utiliza esta base de datos en la nube.

Para SQL Database, en este tutorial se usa Azure SQL Database.

Crear un grupo de recursos

Un grupo de recursos es un contenedor lógico en el que los recursos de Azure, como aplicaciones web, bases de datos y cuentas de almacenamiento, se implementen y administren. Por ejemplo, más adelante puede elegir eliminar todo el grupo de recursos en un solo paso.

En Cloud Shell, cree un grupo de recursos con el comando az group create. En el ejemplo siguiente, se crea un grupo de recursos denominado myResourceGroup en la ubicación Oeste de Europa. Para ver todas las ubicaciones que se admiten en App Service en el nivel Gratis, ejecute el comando az appservice list-locations --sku FREE.

az group create --name myResourceGroup --location "West Europe"

Generalmente se crean el grupo de recursos y los recursos en una región cercana.

Cuando finaliza el comando, una salida de JSON muestra las propiedades del grupo de recursos.

Creación de un servidor lógico de SQL Database

En Cloud Shell, cree un servidor lógico de SQL Database con el comando az sql server create.

Reemplace el marcador de posición <server-name> por un nombre único de SQL Database. Este nombre se usa como parte del punto de conexión SQL Database único global <server-name>.database.windows.net. Los caracteres válidos son a-z, 0-9, -. Reemplace también <db-username> y <db-password> por un nombre de usuario y una contraseña de su elección.

az sql server create --name <server-name> --resource-group myResourceGroup --location "West Europe" --admin-user <db-username> --admin-password <db-password>

Cuando se crea el servidor lógico de SQL Database, la CLI de Azure muestra información similar al ejemplo siguiente:

{
  "administratorLogin": "<db-username>",
  "administratorLoginPassword": null,
  "fullyQualifiedDomainName": "<server-name>.database.windows.net",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Sql/servers/<server-name>",
  "identity": null,
  "kind": "v12.0",
  "location": "westeurope",
  "name": "<server-name>",
  "resourceGroup": "myResourceGroup",
  "state": "Ready",
  "tags": null,
  "type": "Microsoft.Sql/servers",
  "version": "12.0"
}

Configuración de una regla de firewall del servidor

1. Cree una regla de firewall de nivel de servidor de Azure SQL Database mediante el comando az sql server firewall create. Cuando tanto la dirección IP de inicio como final están establecidas en 0.0.0.0., el firewall solo se abre para otros recursos de Azure.

   az sql server firewall-rule create --resource-group myResourceGroup --server <server-name> --name AllowAzureIps --start-ip-address 0.0.0.0 --end-ip-address 0.0.0.0
   

   Sugerencia

   Puede ser incluso más restrictivo con su regla de firewall usando solo las direcciones IP de salida que utiliza su aplicación.

2. En Cloud Shell, ejecute de nuevo el comando para permitir el acceso desde el equipo local y reemplace <your-ip-address> por su dirección IP IPv4 local.

   az sql server firewall-rule create --name AllowLocalClient --server <server-name> --resource-group myResourceGroup --start-ip-address=<your-ip-address> --end-ip-address=<your-ip-address>
   

Crear una base de datos

Cree una base de datos con un nivel de rendimiento S0 en el servidor con el comando az sql db create.

az sql db create --resource-group myResourceGroup --server <server-name> --name coreDB --service-objective S0

Recuperación de la cadena de conexión

Obtenga la cadena de conexión mediante el comando az sql db show-connection-string.

az sql db show-connection-string --client ado.net --server <server-name> --name coreDB

En la salida del comando, reemplace <username> y <password> por las credenciales de administrador de base de datos que usó anteriormente.

Esta es la cadena de conexión de la aplicación ASP.NET Core. Cópiela para usarla más adelante.

Configuración de la aplicación para conectarse a la base de datos de producción

En el repositorio local, abra Startup.cs y busque el código siguiente:

services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlite("Data Source=localdatabase.db"));

Reemplácelo por el código que verá a continuación.

services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("MyDbConnection")));

Ejecución de migraciones de base de datos a la base de datos de producción

Actualmente, la aplicación se conecta a una base de datos SQLite local. Ahora que ha configurado una instancia de Azure SQL Database, vuelva a crear la migración inicial para establecerla como destino.

En la raíz del repositorio, ejecute los siguientes comandos. Reemplace <connection-string> por la cadena de conexión que creó anteriormente.

# Delete old migrations
rm -r Migrations
# Recreate migrations with UseSqlServer (see previous snippet)
dotnet ef migrations add InitialCreate

# Set connection string to production database
# PowerShell
$env:ConnectionStrings:MyDbConnection="<connection-string>"
# CMD (no quotes)
set ConnectionStrings:MyDbConnection=<connection-string>
# Bash (no quotes)
export ConnectionStrings__MyDbConnection=<connection-string>

# Run migrations
dotnet ef database update

Ejecución de la aplicación con una configuración nueva

1. Ahora que las migraciones de base de datos se ejecutan en la base de datos de producción, pruebe la aplicación mediante la ejecución de:

   dotnet run
   

2. Vaya a http://localhost:5000 en un explorador. Seleccione el vínculo Crear nuevo y cree un par de elementos de tareas pendientes. La aplicación ahora lee y escribe datos en la base de datos de producción.

3. Guarde los cambios y confírmelos en el repositorio de Git.

   git add .
   git commit -m "connect to SQLDB in Azure"
   

Ahora está preparado para implementar el código.

Implementación de la aplicación en Azure

En este paso, va a implementar la aplicación ASP.NET Core conectada a SQL Database en App Service.

Configuración de la implementación de Git local

Se puede implementar FTP y Git local en una aplicación web de Azure mediante un usuario de implementación. Una vez configurado este usuario de implementación, podrá usarlo en todas las implementaciones de Azure. El nombre de usuario y la contraseña en el nivel de cuenta son diferentes de las credenciales de suscripción de Azure.

Para configurar el usuario de implementación, ejecute el comando az webapp deployment user set en Azure Cloud Shell. Reemplace <username> y <password> por un nombre de usuario y una contraseña de usuario de implementación.

• El nombre de usuario debe ser único dentro de Azure y no debe contener el símbolo "@" para las inserciones de Git local.
• La contraseña debe tener al menos ocho caracteres y dos de los tres elementos siguientes: letras, números y símbolos.

az webapp deployment user set --user-name <username> --password <password>

La salida JSON muestra la contraseña como null. Si se produce un error 'Conflict'. Details: 409, cambie el nombre de usuario. Si se produce un error 'Bad Request'. Details: 400, use una contraseña más segura.

Anote el nombre de usuario y la contraseña que se usarán para implementar las aplicaciones web.

Creación de un plan de App Service

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE

{ 
  "adminSiteName": null,
  "appServicePlanName": "myAppServicePlan",
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "app",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE --is-linux

{ 
  "freeOfferExpirationTime": null,
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "linux",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

Creación de una aplicación web

az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name <app-name> --deployment-local-git

Local git is configured with url of 'https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "clientCertExclusionPaths": null,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name <app-name> --runtime 'DOTNET|5.0' --deployment-local-git

Local git is configured with url of 'https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

Configuración de la cadena de conexión

Para establecer las cadenas de conexión de la aplicación de Azure, use el comando az webapp config appsettings set en Cloud Shell. En el comando siguiente, reemplace <app-name> y el parámetro <connection-string> por la cadena de conexión que creó anteriormente.

az webapp config connection-string set --resource-group myResourceGroup --name <app-name> --settings MyDbConnection='<connection-string>' --connection-string-type SQLAzure

En ASP.NET Core, puede usar esta cadena de conexión con nombre (MyDbConnection) con el patrón estándar, como cualquier cadena de conexión especificada en appsettings.jon. En este caso, MyDbConnection también se define en appsettings.json. Cuando se ejecuta en App Service, la cadena de conexión definida en App Service tiene prioridad sobre la definida en appsettings.json. El código usa el valor de appsettings.json durante el desarrollo local y el mismo código usa el valor de App Service cuando se implementa.

Para ver cómo se hace referencia a la cadena de conexión en el código, consulte Configuración de la aplicación para conectarse a la base de datos de producción.

Inserción en Azure desde Git

1. Puesto que va a implementar la rama main, debe establecer la rama de implementación predeterminada para la aplicación de App Service en main (consulte Cambio de la rama de implementación). En Cloud Shell, establezca el valor de la aplicación DEPLOYMENT_BRANCH con el comando az webapp config appsettings set.

   az webapp config appsettings set --name <app-name> --resource-group myResourceGroup --settings DEPLOYMENT_BRANCH='main'
   

2. En la ventana del terminal local, agregue una instancia remota de Azure al repositorio de Git local. Reemplace <deploymentLocalGitUrl-from-create-step> por la dirección URL del repositorio Git remoto que guardó en Creación de una aplicación web.

   git remote add azure <deploymentLocalGitUrl-from-create-step>
   

3. Realice la insercion en la instancia remota de Azure para implementar la aplicación con el comando siguiente. Cuando el Administrador de credenciales de Git le solicite las credenciales, asegúrese de que especifica las que creó en Configuración de un usuario de implementación, no las que se usan para iniciar sesión en Azure Portal.

   git push azure main
   

   Este comando puede tardar varios minutos en ejecutarse. Durante la ejecución, muestra información similar a la del ejemplo siguiente:

   Enumerating objects: 268, done.
   Counting objects: 100% (268/268), done.
   Compressing objects: 100% (171/171), done.
   Writing objects: 100% (268/268), 1.18 MiB | 1.55 MiB/s, done.
   Total 268 (delta 95), reused 251 (delta 87), pack-reused 0
   remote: Resolving deltas: 100% (95/95), done.
   remote: Updating branch 'main'.
   remote: Updating submodules.
   remote: Preparing deployment for commit id '64821c3558'.
   remote: Generating deployment script.
   remote: Project file path: .\DotNetCoreSqlDb.csproj
   remote: Generating deployment script for ASP.NET MSBuild16 App
   remote: Generated deployment script files
   remote: Running deployment command...
   remote: Handling ASP.NET Core Web Application deployment with MSBuild16.
   remote: .
   remote: .
   remote: .
   remote: Finished successfully.
   remote: Running post deployment command(s)...
   remote: Triggering recycle (preview mode disabled).
   remote: App container will begin restart within 10 seconds.
   To https://<app-name>.scm.azurewebsites.net/<app-name>.git
    * [new branch]      main -> main
   

   Enumerating objects: 273, done.
   Counting objects: 100% (273/273), done.
   Delta compression using up to 4 threads
   Compressing objects: 100% (175/175), done.
   Writing objects: 100% (273/273), 1.19 MiB | 1.85 MiB/s, done.
   Total 273 (delta 96), reused 259 (delta 88)
   remote: Resolving deltas: 100% (96/96), done.
   remote: Deploy Async
   remote: Updating branch 'main'.
   remote: Updating submodules.
   remote: Preparing deployment for commit id 'cccecf86c5'.
   remote: Repository path is /home/site/repository
   remote: Running oryx build...
   remote: Build orchestrated by Microsoft Oryx, https://github.com/Microsoft/Oryx
   remote: You can report issues at https://github.com/Microsoft/Oryx/issues
   remote: .
   remote: .
   remote: .
   remote: Done.
   remote: Running post deployment command(s)...
   remote: Triggering recycle (preview mode disabled).
   remote: Deployment successful.
   remote: Deployment Logs : 'https://<app-name>.scm.azurewebsites.net/newui/jsonviewer?view_url=/api/deployments/cccecf86c56493ffa594e76ea1deb3abb3702d89/log'
   To https://<app-name>.scm.azurewebsites.net/<app-name>.git
    * [new branch]      main -> main
   

Navegación hasta la aplicación de Azure

1. Vaya a la aplicación implementada mediante el explorador web.

   http://<app-name>.azurewebsites.net
   

2. Agregue algunos elementos de tareas pendientes.

   

¡Enhorabuena! Está ejecutando una aplicación ASP.NET Core controlada por datos en App Service.

Actualización local y nueva implementación

En este paso, modificará el esquema de la base de datos y lo publicará en Azure.

Actualización del modelo de datos

Abra Models/Todo.cs en el editor de código. Agregue la siguiente propiedad a la clase ToDo:

public bool Done { get; set; }

Nueva ejecución de migraciones de base de datos

Ejecute algunos comandos para realizar actualizaciones en la base de datos de producción.

dotnet ef migrations add AddProperty
dotnet ef database update

Uso de la nueva propiedad

Realice algunos cambios en el código para usar la propiedad Done. Para simplificar, en este tutorial va a cambiar las vistas Index y Create para ver la propiedad en acción.

1. Abra Controllers/TodosController.cs.

2. Busque el método Create([Bind("ID,Description,CreatedDate")] Todo todo) y agregue Done a la lista de propiedades en el atributo Bind. Cuando haya terminado, la firma del método Create() se parecerá al código siguiente:

   public async Task<IActionResult> Create([Bind("ID,Description,CreatedDate,Done")] Todo todo)
   

3. Abra Views/Todos/Create.cshtml.

4. En el código Razor debería ver un elemento <div class="form-group"> para Description y, luego, otro elemento <div class="form-group"> para CreatedDate. Inmediatamente después de estos dos elementos, agregue otro elemento <div class="form-group"> para Done:

   <div class="form-group">
       <label asp-for="Done" class="col-md-2 control-label"></label>
       <div class="col-md-10">
           <input asp-for="Done" class="form-control" />
           <span asp-validation-for="Done" class="text-danger"></span>
       </div>
   </div>
   

5. Abra Views/Todos/Index.cshtml.

6. Busque el elemento vacío <th></th>. Justo encima de este elemento, agregue el siguiente código Razor:

   <th>
       @Html.DisplayNameFor(model => model.Done)
   </th>
   

7. Busque el elemento <td> que contiene los asistentes de etiquetas asp-action. Justo encima de este elemento, agregue el siguiente código Razor:

   <td>
       @Html.DisplayFor(modelItem => item.Done)
   </td>
   

Eso es todo lo que necesita para ver los cambios en las vistas Index y Create.

Prueba de los cambios localmente

1. Ejecute localmente la aplicación.

   dotnet run
   

   Nota

   Si abre una nueva ventana de terminal, debe establecer la cadena de conexión en la base de datos de producción en el terminal, como hizo en Ejecución de migraciones de base de datos a la base de datos de producción.

2. Abra el explorador y vaya a http://localhost:5000/. Ahora puede agregar una tarea pendiente y marcar Listo. A continuación se debería mostrar en su página principal como un elemento completado. Recuerde que la vista Edit no muestra el campo Done, dado que no cambió la vista Edit.

Publicación de los cambios en Azure

1. Confirme los cambios en Git e insértelo en la aplicación de App Service.

   git add .
   git commit -m "added done field"
   git push azure main
   

2. Una vez que git push esté completo, vaya a la aplicación de App Service e intente agregar un elemento de tarea y active Listo.

   

Aún se muestran todas las tareas pendientes existentes. Cuando vuelva a publicar la aplicación ASP.NET Core, no se perderán los datos existentes en la instancia de SQL Database. Además, las migraciones de Entity Framework Core solo cambia el esquema de datos y deja intactos los datos existentes.

Transmisión de registros de diagnóstico

Mientras la aplicación ASP.NET Core se ejecuta en Azure App Service, puede hacer que los registros de la consola se canalicen a Cloud Shell. De este modo, puede obtener los mismos mensajes de diagnóstico para ayudarle a depurar errores de la aplicación.

El proyecto de ejemplo ya sigue las instrucciones del proveedor de registro de Azure App Service con dos cambios de configuración:

• Incluye una referencia a Microsoft.Extensions.Logging.AzureAppServices en DotNetCoreSqlDb.csproj.
• Llama a loggerFactory.AddAzureWebAppDiagnostics() en Program.cs.

1. Para establecer el nivel de registro de ASP.NET Core en App Service en Information desde el nivel predeterminado Error, utilice el comando az webapp log config en Cloud Shell.

   az webapp log config --name <app-name> --resource-group myResourceGroup --application-logging filesystem --level information
   

   Nota

   El nivel de registro del proyecto ya está establecido en Information en appsettings.json.

2. Para iniciar la transmisión del registro, use el comando az webapp log tail en Cloud Shell.

   az webapp log tail --name <app-name> --resource-group myResourceGroup
   

3. Cuando las secuencias de registro se inicien, actualice la aplicación de Azure en el explorador para obtener tráfico web. Ahora puede ver los registros de la consola canalizados al terminal. Si no ve los registros de la consola de inmediato, vuelve a comprobarlo en 30 segundos.

4. Para detener el streaming del registro en cualquier momento, escriba Ctrl+C.

Para más información acerca de cómo personalizar los registros de ASP.NET Core, consulte Registro en .NET.

Limpieza de recursos

En los pasos anteriores, creó recursos de Azure en un grupo de recursos. Si prevé que no necesitará estos recursos en el futuro, elimine el grupo de recursos ejecutando el siguiente comando en Cloud Shell:

az group delete --name myResourceGroup

Este comando puede tardar varios segundos en ejecutarse.

Pasos siguientes

¿Qué ha aprendido?

Vaya al siguiente tutorial para aprender a asignar un nombre DNS personalizado a una aplicación web.

O bien, eche un vistazo a otros recursos: