# 15.2 Generando Artifacts en Azure Pipelines

Para explicar la flexibilida de .net y Azure Pipelines voy a publicar 2 artifacts con el mismo código, uno para instalarlo en un  AppService en Linux con Azure con una base de datos MySQL y el otro para publicar en el AppService en Windows Con Azure. 

Una parte interesante de Azure pipelines es que te permite crear variables de tipo Secret, las cuales estan ocultas y son independientes del código. Vamos a agregar una variable para guardar la cadena de conexión donde vamos a tener nuestra base de datos de MySQL puedes tener la bd de MySQL en un hosting, un servidor o en Azure. Esta cadena de conexión se va a reemplazar en el momento en que generamos el  Pipeline para poder generar el script que actualizará la base de datos.

### Modificando el Pipeline para generar el Artifact para publicar a Azure.

#### Agregando variables

1. Entramos a Azure Devops en la opción Pipelines. Selecciona el último Pipeline y da clic en **Edit**.

![](/files/-M5nQTIf_PuHYNn7_NM9)

2\. Damos clic en el botón **Variables** para agregar una variable de tipo secret que tendra nuestra cadena de conexión, al tenerla en variable la cadena de conexión no esta disponible en el código fuente. 

![](/files/-M5nRURysanMvnORlJLZ)

3\. Da clic en el botón **+** para agregar una nueva variable. En la imagen ya tengo agregada la imagen, como es de tipo secreta solo se ve el nombre pero no el valor. 

![](/files/-M5nTb4bfgTeSMCBJx3D)

Como ejemplo voy a agregar otra variable para la base de datos de SQL de Azure. Con el nombre AzureSQLServer y en value agrego la cadena de conexión de Azure.

```
Server=tcp:armhe.database.windows.net,1433;
Initial Catalog=CaducaRest;Persist Security Info=False;
User ID=AdminCaduca;Password=tuPassword;
MultipleActiveResultSets=False;Encrypt=True;
TrustServerCertificate=False;Connection Timeout=30;
```

![](/files/-M5nTDqhvAbsNni0MR1W)

Puedes ver que se agrega la variable. Da clic en **Save.**

![](/files/-M5nTTyZ5n7yz0w02JyQ)

4\. En la sección de variables puedes agregar las variables que deseas cambiar de tu archivo appsettings.json

{% code title="appsettings.json" %}

```javascript
{
  "ConnectionStrings": {
    "DefaultConnection": "server=localhost;port=3306;database=caduca;user=AdminCaduca;Password=StKRV6MR6A;sslMode=none",
    "SQLServerConnection": "Server=localhost;Database=caduca;User Id=AdminCaduca;Password=StKRV6MR6A;",
    "AzureSQLConnection": "Server=tcp:armhe.database.windows.net,1433;Initial Catalog=CaducaRest;Persist Security Info=False;User ID=AdminCaduca;Password=StKRV6MR6A;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
  },
  "Tokens": {
    "Key": "4eQXP7GTCTRwC6x6",
    "Issuer": "http://localhost:5000",
    "Audience": "http://localhost:5000"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Debug"
    }
  },
  "AllowedHosts": "*"
}
```

{% endcode %}

Por ejemplo para cambiar la cadena de Conexión **DefaultConnection** debemos agregar una variable con el nombre **ConnectionStrings.DefaultConnection**, para cada nivel del json se sustituye con un punto (.). Para utilizar las variables que definimos agregamos la variable con $ y entre paréntesis. Ejemplo **$(Mysql).**

```yaml
variables:
  solution: '**/*.sln'
  buildPlatform: 'Any CPU'
  buildConfiguration: 'Release'
  system.debug: false
  ConnectionStrings.DefaultConnection: $(Mysql)

```

Para practicar el remplazo de variables puedes agregar variables para cambiar el key, Issuer, Audience, el nivel de log, con variables secretas o directamente en el código yaml. Como el código yaml se incluye en el repositorio de Github, es mejor utilizar variables para los valores que no deseas que esten disponibles para cualquier programador en el código fuente.

El archivo yaml queda de la siguiente manera**:**

![](/files/-M5oDtkva_3LQUbW17gF)

{% code title="azure-pipelines.yml" %}

```yaml
variables:
  solution: '**/*.sln'
  buildPlatform: 'Any CPU'
  buildConfiguration: 'Release'
  system.debug: false
  ConnectionStrings.DefaultConnection: $(Mysql)
  Tokens.Key: $(key)
  Tokens.Issuer: $(issuer)
  Tokens.Audience: $(issuer)
  Logging.LogLevel.Default: "Error"
```

{% endcode %}

**12.1.2 Transformando el appsettings con las variables .**

Agrega un task llamado **File Transform** para remplazar los valores de archivos json o xml por las variables definidas en nuestro pipeline.

![](/files/-M6HcuYs1Zauk7V2zasw)

Agrega lo siguiente:

* **Package or folder**: Agrega la dirección de la carpeta donde esta el archivo que deseas cambiar. En este caso es: **$(build.SourcesDirectory)/CaducaRest/**
* **XML Transformation rules**: Aqui se agregan las reglas para transformar algún webconfig.xml en este caso no voy a realizar ningún cambio al webcofig o algún otro xml por lo que voy a borrar el contenido por default.
* **Json target files:** Selecciona los archivos json que deseas cambiar. En este caso solo deseo cambiar el archivo appsettings, por lo tanto teclea el valor **\*\*/appsettings.json**
* **Xml target files:** Aquí se seleccionan los archivos xml que deseas cambiar, en este caso no necesito cambiar nada.

![](/files/-M6HddJ8J7QkjJmYn3Hv)

Puedes ver la documentación oficial de este task [aquí](https://github.com/microsoft/azure-pipelines-tasks/blob/master/Tasks/FileTransformV2/README.md).

Da clic en el botón Add y borra la propiedad del xml. Queda de la siguiente manera. Siempre agrego la propiedad displayName para tener un nombre mas descriptivo en este caso es: **Transformar appsettings.**

```yaml
- task: FileTransform@2
  displayName: "Transformar appsettings"
  inputs:
    folderPath: '$(build.SourcesDirectory)/CaducaRest/'
    jsonTargetFiles: '**/appsettings.json'
```

#### 12.1.3 Instalado Entity Framework

Para poder generar el script de MySQL para las migraciones necesitamos instalar la herramienta para ef, la podemos instalar con el siguiente comando:

```yaml
dotnet tool install --global dotnet-ef
```

Para esto agrega una tarea **Command line** y en el área de Script agrega el comando

![](/files/-M6HiwrjujPTzmCXGQ6C)

El archivo yaml queda de la siguiente manera:

```yaml
- task: CmdLine@2
  displayName: "Instalar .NET Global"
  inputs:
    script: 'dotnet tool install --global dotnet-ef'
```

#### 12.1.4 Generando el script para actualizar la base de datos.

Después de generar el build del proyecto de Caduca Rest podemos agregar el siguiente comando para generar un script para actualizar la base de datos, con los siguientes parámetos:

* -**p:** Indicas la ruta y el nombre del archivo de tu proyecto, el cual termina en .csproj, en este caso es **$(build.SourcesDirectory)\CaducaRest\CaducaRest.csproj**
* **-i:** Genera un script que se puede utilizar en cualquier base de datos, se tenga un cambio o no en el commit.
* -**o:** Indicas la ruta y nombre del archivo .sql con los cambios para la base de datos. En mi caso lo quiero en la ruta Scripts con el nombre update\_to\_latest.sql. **$(Build.ArtifactStagingDirectory)\Scripts\update\_to\_latest.sql**

El comando a ejecutar queda de la siguiente manera:

```yaml
dotnet ef migrations script 
-p $(build.SourcesDirectory)\CaducaRest\CaducaRest.csproj 
-i -o $(Build.ArtifactStagingDirectory)
\Scripts\update_to_latest.sql
```

Para ejecutar este comando agrega el siguiente yaml.

```yaml
- script: dotnet ef migrations script -p $(build.SourcesDirectory)\CaducaRest\CaducaRest.csproj -i -o $(Build.ArtifactStagingDirectory)\Scripts\update_to_latest.sql
  displayName: 'Generar Script'
```

Puedes ver la referencia completa del comando [aquí](https://docs.microsoft.com/es-mx/ef/core/miscellaneous/cli/dotnet).

#### 12.1.5 Generando un Artifact para Linux.

Agrega una tarea de **.Net Core** para generar los archivos necesarios  para publicar los archivos necesarios para linux.

* **Command:** Seleciona **publish** para generar los archivos necesarios.
* **Arguments:** Agrega los siguientes argumentos:

  *  **-r:** Selecciona runtime, en este caso para linux es **linux-x64** Este parámetro es opcional cuando el App Service no tiene la misma versión que tu código. Anteriormente se tardaban algunas semanas en tener listo app services con la mas reciente versión de .Net Core.
  * **-configuration:** Selecciona la configuración que esta al inicio del pipeline **$(BuildConfiguration)** 
  * -**-output:** Selecciona la ruta donde se van  a publicar los archivos, en este caso es **$(Build.ArtifactStagingDirectory)/linux** 

![](/files/-M6Hs-BvY6hxm2-nnG16)

La tarea queda de la siguiente manera:

```yaml
- task: DotNetCoreCLI@2
  displayName: "Publish Linux"
  inputs:
        command: 'publish'
        publishWebProjects: true
        arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)'
        zipAfterPublish: true
```

Puedes ver la documentación oficial del comando publish [aquí](https://docs.microsoft.com/es-mx/dotnet/core/tools/dotnet-publish).

#### 12.1.6 Generando un Artifact para Windows.

Para windows solo voy a configurar el directorio de salida.

```yaml
--output $(Build.ArtifactStagingDirectory)/win
```

```yaml
- task: DotNetCoreCLI@2
  displayName: "Publish Win"
  inputs:
        command: 'publish'
        publishWebProjects: true
        arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)/win'
        zipAfterPublish: true
```

#### 12.1.7 Publicando los Artifacts.

Por último después de los scripts de pruebas, agrega una tarea **Publish build artifacts** para generar artifacts para windows, linux y el script de sql.

Configura la tarea de la siguiente manera:

* **Path to publish:** selecciona la carpeta que deseas publicar, en el caso de linux será $(Build.ArtifactStagingDirectory)/linux
* **Artifact name**: Teclea el nombre el artifacto en este caso sera restLinux
* **Artifact publish Location:** Selecciona si deseas publicarlo en el pipeline o en una carpeta compartida.

![](/files/-M6HxbVieF4NMLfeKOaV)

La tarea queda de la siguiente manera:

```yaml
- task: PublishBuildArtifacts@1
  displayName: "Upload Artifacts linux"
  inputs:
        pathtoPublish: '$(Build.ArtifactStagingDirectory)/linux' 
        artifactName: 'restLinux' 
```

Puedes agregar las demás tareas para publicar el artifact de windows y el script de sql.

Puedes ver la documentación oficial de la tarea de publish [aquí](https://docs.microsoft.com/en-us/azure/devops/pipelines/tasks/utility/publish-build-artifacts?view=azure-devops).

El archivo queda de la sigueinte manera:

```yaml
# ASP.NET Core (.NET Framework)
# Build and test ASP.NET Core projects targeting the full .NET Framework.
# Add steps that publish symbols, save build artifacts, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/dotnet-core

trigger:
- master

pool:
  vmImage: 'windows-latest'

variables:
  solution: '**/*.sln'
  buildPlatform: 'Any CPU'
  buildConfiguration: 'Release'
  system.debug: false
  ConnectionStrings.DefaultConnection: $(SQL)
  Tokens.Key: $(key)
  Tokens.Issuer: $(issuer)
  Tokens.Audience: $(issuer)
  Logging.LogLevel.Default: "Error"

steps:

- task: UseDotNet@2 
  displayName: "Instalar .NET Core 7.0.x"
  inputs:
        version: '7.0.x'
        performMultiLevelLookup: true
        packageType: sdk

- task: CmdLine@2
  displayName: "Instalar .NET Global"
  inputs:
    script: 'dotnet tool install --global dotnet-ef'

- task: DotNetCoreCLI@2
  displayName: 'Build CaducaRest'
  inputs:
    command: build
    projects: |
      **/CaducaRest/CaducaRest.csproj

- task: DotNetCoreCLI@2
  displayName: Testing Unit Test
  inputs:
    command: 'test'
    projects: '**/CaducaRest.UnitTest/*.csproj'
    arguments: '--configuration $(buildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura /p:CoverletOutput=$(Build.SourcesDirectory)/TestResults/Coverage/'
    publishTestResults: true
    testRunTitle: 'Unit Test'

- task: DotNetCoreCLI@2
  displayName: Testing Integration Test
  inputs:
    command: 'test'
    projects: '**/CaducaRest.IntegrationTest/*.csproj'
    arguments: '--configuration $(buildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura /p:CoverletOutput=$(Build.SourcesDirectory)/TestResults/Coverage/'
    publishTestResults: true
    testRunTitle: 'Integration Test'
  env:
    CARLOS: $(CARLOS)
    JUAN: $(JUAN)
    MARIA: $(MARIA)
    
- task: SpecFlowPlus@0
  displayName: Specflow plus
  condition: always()
  inputs:
    generatorSource: 'TestAssembly'
    testAssemblyFilePath: '$(Build.SourcesDirectory)\CaducaRest.IntegrationTest\bin\Release\net7.0\CaducaRest.IntegrationTest.dll'
    projectName: 'Integration'
    testExecutionJson: '$(Build.SourcesDirectory)\CaducaRest.IntegrationTest\bin\Release\net7.0\TestExecution.json'
    projectLanguage: 'es'

- task: PublishCodeCoverageResults@1
  displayName: 'Publish code coverage report'
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '$(Build.SourcesDirectory)/**/coverage.cobertura.xml'

- task: DotNetCoreCLI@2
  displayName: 'Build playwright'
  inputs:
    command: build
    projects: |
      **/CaducaRest.PlayWright.UITest/*.csproj

- task: CopyFiles@2
  displayName: Copy postman scripts
  inputs:
    SourceFolder: 'CaducaRest.IntegrationTest/postman'
    Contents: '**'
    TargetFolder: '$(Build.ArtifactStagingDirectory)/postman'

- task: FileTransform@2
  displayName: "Transformar appsettings"
  inputs:
    folderPath: '$(build.SourcesDirectory)/CaducaRest/'
    jsonTargetFiles: '**/appsettings.json'

- script: dotnet ef migrations script -p $(build.SourcesDirectory)\CaducaRest\CaducaRest.csproj -i -o $(Build.ArtifactStagingDirectory)\Scripts\update_to_latest.sql
  displayName: 'Generar Script'

- script: dotnet ef migrations bundle -p $(build.SourcesDirectory)\CaducaRest\CaducaRest.csproj --verbose --configuration --force
  displayName: 'Generar Bundle'

- task: DotNetCoreCLI@2
  displayName: "Publish Linux"
  inputs:
        command: 'publish'
        publishWebProjects: true
        arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)/linux'
        zipAfterPublish: true

- task: DotNetCoreCLI@2
  displayName: "Publish Win"
  inputs:
        command: 'publish'
        publishWebProjects: true
        arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)/win'
        zipAfterPublish: true
- task: DotNetCoreCLI@2
  displayName: "Build Selenium testing"
  inputs:
    command: 'publish'
    publishWebProjects: false
    projects: '**/CaducaRest.UITest/*.csproj' 
    arguments: '--configuration $(BuildConfiguration) --output $(Build.ArtifactStagingDirectory)/selenium'
    zipAfterPublish: false

- task: CopyFiles@2
  displayName: Copy Playwright
  inputs:
    SourceFolder: '$(Pipeline.Workspace)/s/CaducaRest.PlayWright.UITest/bin/Debug/net7.0/'
    Contents: '**'
    TargetFolder: '$(Build.ArtifactStagingDirectory)/playwright'

- task: PublishBuildArtifacts@1
  displayName: "Upload Artifacts linux"
  inputs:
        pathtoPublish: '$(Build.ArtifactStagingDirectory)/linux' 
        artifactName: 'restLinux' 

- task: PublishBuildArtifacts@1
  displayName: "Upload Artifacts win"
  inputs:
        pathtoPublish: '$(Build.ArtifactStagingDirectory)/win' 
        artifactName: 'restWin' 

- task: PublishBuildArtifacts@1
  displayName: "Upload Artifacts postman"
  inputs:
        pathtoPublish: '$(Build.ArtifactStagingDirectory)/postman' 
        artifactName: 'postmanTesting' 

- task: PublishBuildArtifacts@1
  displayName: "Upload Artifacts selenium"
  inputs:
        pathtoPublish: '$(Build.ArtifactStagingDirectory)/selenium' 
        artifactName: 'seleniumTesting' 

- task: PublishBuildArtifacts@1
  displayName: "Upload Artifacts playwright"
  inputs:
        pathtoPublish: '$(Build.ArtifactStagingDirectory)/playwright' 
        artifactName: 'playwrightTesting' 

 - task: PublishBuildArtifacts@1
   displayName: "Upload Artifacts SQL"
   inputs:
         pathtoPublish: '$(Build.ArtifactStagingDirectory)/Scripts' 
         artifactName: 'Scripts' 
```

Listo, si todo fue correcto cada vez que le des commit a tu código se crearán los artifacts. Solo hay un error en el reemplazo de variables que después voy a revisar porque marca error.

En el ejemplo tengo 5 artifacts porque tengo ya configurado los artifacts para postman y selenium que explicaré mas adelante.

En el botón View 3 changes se tiene la lista de cambios, ya sea en el commit o la lista de tareas cambiadas en Azure Devops.

![](/files/-M6HzijYUwbRll8diHGG)

Un ejemplo de la lista de cambios es el siguiente

![](/files/-M6HzvDfwBvHjE1UHPwC)

Si das clic en el link de los artifacts puedes ver la lista de artifacts y los puedes descargar.

![](/files/-M6I-s__38d9hJxpPlsS)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://abi.gitbook.io/net-core/12.-entrega-continua-continuous-delivery/12.1-publicando-automaticamente-a-azure.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.