Bienvenue sur notre blog Infeeny !

Retrouvez ici tous les Posts (+ de 700) des consultants et experts du groupe Infeeny (Plus de 330 collaborateurs, pure player Microsoft).

Vous voulez en savoir plus sur Infeeny ou vous souhaitez nous rejoindre ?
Consultez notre site infeeny.com

Vous pouvez aussi nous suivre sur :
Twitter : @Infeeny_fr – https://twitter.com/Infeeny_fr
LinkedIn : https://www.linkedin.com/company/infeeny
– et vous abonner à notre chaîne YouTube Infeeny !

Comment sécuriser son Azure Virtual WAN avec Azure Firewall et Azure Firewall Manager (preview)

Azure Firewall Manager (preview)

Introduction

Pour pouvoir suivre cet article sereinement, il faut avoir un minimum de connaissances en matière de SD-WAN/Azure virtaul WAN. L’une des dernières mises à jour de vWAN et qui rend l’outil encore plus intéressant, est la possibilité de déployer une instance d’Azure Firewall sur le Hub. Cette fonctionnalité est fournie avec un autre service, Azure Firewall Manager, sur lequel je voudrais me concentrer aujourd’hui.

Azure Firewall Manager a été publié très récemment, lors du dernier Ignite. Le service permet aux utilisateurs de déployer de manière centralisée des instances d’Azure Firewall sur différents vHubs, sur plusieurs régions et souscriptions. Une fois provisionnées, ces instances peuvent être gérées de manière centralisée en ce qui concerne les règles de pare-feu. Les règles peuvent désormais être déployées de manière hiérarchique, ce qui signifie que l’équipe informatique centrale (global admin) peut fournir une politique globale, en plus de laquelle les organisations locaux peuvent implémenter leurs propres politiques de règles plus spécifiques. Un seul niveau d’héritage est cependant autorisé.

Dans le format actuel, le service offre la possibilité de déployer des pare-feu sur des vHUB créés dans un Azure virtuel WAN. Firewall Manager propose également une gestion centralisée des itinéraires. Cette fonctionnalité est fantastique à mon avis – avec un seul commutateur, nous pouvons forcer le trafic via le pare-feu, sans avoir à créer des itinéraires définis par l’utilisateur.

Objectif de cet article

Dans cet article, nous allons voir comment déployer des vSecure HUB dans un environnement Azure WAN afin de tester les fonctionnalités d’Azure Firewall Manager. Pour cela, nous utiliserons Azure CLI, à ce jour, il n’est toujours pas possible de le faire en Powershell/Terraform.

Notre exemple portera sur les ressources suivantes :

  • 1 Azure Virtual WAN
  • 3 vHUB
    • un virtual HUB pour la region west-us
    • un virtual HUB pour la region east-us
    • un virtual HUB pour la region west-europe
  • 1 VPN Gateway (branch onpremise)
  • 4 Azure Firewall Policy (preview)
    • root-policy (global admin)
    • westus-region-policy (local admin)
    • eastus-region-policy (local admin)
    • westeurope-region-policy (local admin)

Let’s Go !

Pour avoir une image de l’infrastructure cible, voici un schéma récapitulatif.

Virtual Azure WAN

Commençons par créer le Azure Virtual WAN.

az group create --location eastus  --name demo-rg-vwan


# Virtual WAN
az extension add --name virtual-wan

az network vwan create --name demo-virtual-wan --resource-group demo-rg-vwan --branch-to-branch-traffic true --location eastus --type Standard  --vnet-to-vnet-traffic true

Azure Virtual HUB

Créez les Azure Virtual HUB.

# the west-us hub region
az network vhub create --address-prefix 10.100.0.0/16  --name demo-hub-westus  --resource-group demo-rg-vwan  --vwan demo-virtual-wan  --location westus  --sku  Standard

# the east-us hub region
az network vhub create --address-prefix 10.200.0.0/16  --name demo-hub-eastus  --resource-group demo-rg-vwan --vwan demo-virtual-wan  --location eastus  --sku  Standard

# the west-europe hub region
az network vhub create --address-prefix 10.255.0.0/16  --name demo-hub-westeurope  --resource-group demo-rg-vwan  -vwan demo-virtual-wan  --location westeurope --sku  Standard

Créez une Firewall-Policies et sécurisez les hub

Créez les Firewall-Policies.

# vSecure HUB policy

az extension add --name azure-firewall

az network firewall policy create --name fw-policy-root  --resource-group demo-rg-vwan   --location eastus    --threat-intel-mode Alert

az network firewall policy create --name fw-policy-westeurope   --resource-group demo-rg-vwan  --location eastus  --threat-intel-mode Alert  --base-policy fw-policy-root
                                                                              

az network firewall policy create --name fw-policy-westus  --resource-group demo-rg-vwan  --location eastus  --threat-intel-mode Alert --base-policy fw-policy-root
                                                                               

az network firewall policy create --name fw-policy-eastus  --resource-group demo-rg-vwan  --location eastus  --threat-intel-mode Alert --base-policy fw-policy-root

Connectez les Vnets/Branch

# VPN Gateway site-to-site (onpremise branch of east-us region)

az network vpn-gateway create --name demo-vpn-gateway   --resource-group demo-rg-vwan  --vhub demo-hub-eastus  --location eastus

az network vpn-site create --ip-address 137.117.35.59  --name demo-vpn-site  --virtual-wan demo-virtual-wan  --resource-group demo-rg-vwan --address-prefixes 10.5.0.0/16  --device-model firewall --device-vendor paloalto  --link-speed 20  --location eastus
                           
az network vpn-gateway connection create --gateway-name demo-vpn-gateway --name demo-vpn-gateway-connection --remote-vpn-site demo-vpn-site --resource-group demo-rg-vwan --connection-bandwidth 50 --protocol-type IKEv2 --shared-key ######################

# Virtual Hub to VNET connection (VNET Branch west us gerios)

az network vhub connection create --name  vnet-westus-prod-to-hub --remote-vnet "remote-vnet-id" --resource-group demo-rg-vwan --vhub-name  demo-hub-westus --internet-security true 

# Virtual Hub to VNET connection (VNET Branch west europe gerios)

az network vhub connection create --name  vnet-westeurope-prod-to-hub --remote-vnet "remote-vnet-id" --resource-group demo-rg-vwan  --vhub-name  demo-hub-westeurope --internet-security true --remote-vnet-transit   true --use-hub-vnet-gateways true

n’oubliez pas de configurer le tunnel IPSEC sur votre Appliance onpremise.

Creez vos Rules/Collections

# Policies

az network firewall policy rule-collection-group create --name rule-collection-westeurope --policy-name fw-policy-westeurope --priority 100 --resource-group demo-rg-vwan --location eastus

az network firewall policy rule-collection-group collection add-nat-collection --collection-priority 100 --name nat-collection --policy-name fw-policy-westeurope --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westeurope --action DNAT --destination-addresses 51.124.93.205 --destination-ports 22 --ip-protocols TCP --rule-name nat-ssh --source-addresses *  --translated-address 10.0.1.4  --translated-port 22 

az network firewall policy rule-collection-group collection add-filter-collection --collection-priority 200 --name net-collection --policy-name fw-policy-westeurope --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westeurope --action Allow --destination-ports *  --ip-protocols Any --protocols * --rule-name allowall --rule-type NetworkRule --source-addresses 10.0.0.0/16 --destination-addresses 10.0.0.0/16



az network firewall policy rule-collection-group create --name rule-collection-westus --policy-name fw-policy-westus --priority 100 --resource-group demo-rg-vwan --location eastus

az network firewall policy rule-collection-group collection add-nat-collection --collection-priority 100 --name nat-collection --policy-name fw-policy-westus --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westus --action DNAT --destination-addresses 13.83.64.91  --destination-ports 22 --ip-protocols TCP --rule-name nat-ssh --source-addresses *  --translated-address 10.0.0.4  --translated-port 22 

az network firewall policy rule-collection-group collection add-filter-collection --collection-priority 200 --name net-collection --policy-name fw-policy-westus --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-westus --action Allow --destination-ports *  --ip-protocols Any --protocols * --rule-name allowall --rule-type NetworkRule --source-addresses 10.0.0.0/16 --destination-addresses 10.0.0.0/16
                                                                                                                        

az network firewall policy rule-collection-group create --name rule-collection-eastus --policy-name fw-policy-eastus --priority 100 --resource-group demo-rg-vwan --location eastus

az network firewall policy rule-collection-group collection add-filter-collection --collection-priority 200 --name net-collection --policy-name fw-policy-eastus --resource-group demo-rg-vwan --rule-collection-group-name rule-collection-eastus --action Allow --destination-ports *  --ip-protocols Any --protocols * --rule-name allowall --rule-type NetworkRule --source-addresses 10.0.0.0/8 --destination-addresses 10.0.0.0/8
 

Et enfin acheminer le trafic vers votre hub

Vous devez maintenant vous assurer que le trafic réseau est acheminé via votre vSecure Hub. Cette étape n’étant toujours pas disponible en Cli/Powershell/Terraform, on le fera directement sur le portail.

  1. depuis l’interface Firewall Manager, select Secured virtual hubs.
  2. Select the Hub.
  3. Under Settings, select Route settings.
  4. Under Internet trafficTraffic from Virtual Networks, select Send via Azure Firewall.
  5. Under Azure private trafficTraffic to Virtual Networks, select Send via Azure Firewall.
  6. Select Edit IP address prefix(es).
  7. Select Add an IP address prefix.
  8. Under Settings, select Connections.
  9. Select the spoke (VNETs/VPN site-site) connection, and then select Secure internet traffic and then select OK.

Conclusion

Je n’ai pas encore effectué de tests plus poussés, mais jusqu’à présent, je suis très satisfait de ce nouveau service. Une fois qu’il aura atteint la disponibilité générale, il pourrait rejoindre facilement notre Azure Virtual WAN pour former « Le » meilleure package d’outils pour le déploiement de réseaux de types Hub & Spoke natif Azure, et je vous laisse imaginez à quel point cette manière de faire facilitera la manipulation des pipelines CI / CD par rapport à notre façon de faire actuelle. 

VM Insights : Surveiller les performances et dépendances des VMs Azure

Surveiller ses environnements Azure est très important. Pour cela nous connaissons bien la solution Azure Monitor qui nous permet justement de surveiller et analyser nos environnements Azure. Azurer Monitor nous permet également d’être alerté si un incident survient sur notre plateforme.

              L’une des nouvelles fonctionnalités d’Azure Monitor est VM Insights. Elle nous permet de visualiser les performances et les dépendances de nos machines virtuelles. VM Insights se base sur les logs de VMS récupérés par les collecteurs de données Log Analytics.

              Voici les points qui seront traités :

  • Comment activer VM Insights : depuis le Portail et en PowerShell
  • Comment embarquer les VMs dans la solution : depuis le Portail et en PowerShell
  • Gérer les alertes en PowerShell

A l’issue de cet article vous saurez comment activer la solution et y embarquer les VMs automatiquement avec un script PowerShell complet et expliqué.

Activation de VM insights :

Il existe différentes méthodes pour activer VM Insights parmi lesquelles :

Directement sur le portail Azure

  • En ajoutant la solution au niveau d’un Log Analytics Workspace
    • En activant la solution depuis la machine virtuelle : dans le volet Monitoring de la VM > Insights > Enable / Activer.

L’activation de VM Insights directement depuis la VM, permet, en même temps d’activer la fonctionnalité VM Insights et d’embarquer la VM dans la solution. Une fois la fonctionnalité activée nous avons une visualisation des dépendances et performances de notre machine virtuelle comme représenté sur les Dashboards ci-dessous :

Visualisation des performances : Indicateur sur l’utilisation de la CPU, sur les espaces disques, les IOPS ou encore l’utilisation de la mémoire.

Visualisation des dépendances : nous permet notamment de voir avec quels environnements échange la VM et sur quels ports ou encore quels processus sont lancés sur la VM.

En ligne de commande

              Comme expliqué précédemment, la fonctionnalité VM Insights se base sur un Log Analytics Workspace. Nous devons donc commencer par en créer un ou récupérer les informations du Workspace déjà existant que l’on souhaite utiliser, ce sera le cas dans mon exemple. Voici le code permettant de récupérer les propriétés d’un Workspace existant puis d’ensuite activer la solution VM Insights :

# Get Log Analytics Workspace properties
$law = Get-AzOperationalInsightsWorkspace -ResourceGroupName $rgName 

#Set in a variable VM Insights solution Name
$SolutionName = "VMInsights"
 
#Enable VMInsights Solution on the Log Analytics Workspace
Set-AzOperationalInsightsIntelligencePack -ResourceGroupName $rgName -WorkspaceName $law.Name -IntelligencePackName $SolutionName -Enabled $true 

Comment embarquer les VMs dans la solution

              Pour embarquer des VMs dans la solution nous pouvons le faire comme expliqué précédemment directement depuis la VM ou bien via PowerShell. Il est important de comprendre comment le lien se fait entre les VMs et la solution VM Insights. Lors de l’activation de la solution pour une VM, 2 agents sont poussés dans la VM. Les agents sont les suivants :

  • Pour les VMs WINDOWS : Microsoft Monitoring Agent et Dependency Agent Windows
  • Pour les VMs Linux : Oms Agent For Linux et Dependency Agent Linux

              Si l’on souhaite déployer VM Insights sur un ensemble de VMs, nous n’allons pas passer par une activation de la solution à la main VM par VM depuis le portail. C’est tout l’intérêt du script PowerShell qui suit :

              Nous commençons par récupérer une liste de VMs pour lesquelles nous souhaitons analyser les performances et dépendances. Ici nous récupérons toutes les VMs d’un groupe de ressources :

# List all VMs in the resource group 
$azVMs = Get-AzVM -ResourceGroupName $rgName

              Ensuite, nous automatisons le déploiement des 2 Agents sur chaque VM de notre groupe de ressource en fonction de l’OS de la machine. Deux paramètres sont importants pour pousser l’installation des agents : l’ID du Workspace et la clé d’accès à ce dernier. Ce qui donne le code suivant :

$PublicSettings = @{"workspaceId" = $law.CustomerId}
$ProtectedSettings = @{"workspaceKey" = $lawKey}

# Push Agents Install on VMS to enable VM Insights
foreach ($vm in $azVMs) {
    # get VM's Os type

    $OsType = $vm.StorageProfile.OsDisk.OsType

    # Filter installation extension name by the Os type of the VM
    if($OsType -eq "Windows"){

        Set-AzVMExtension -ExtensionName "MMAExtension" `
            -ResourceGroupName $rgName `
            -VMName $vm.Name `
            -Publisher "Microsoft.EnterpriseCloud.Monitoring" `
            -ExtensionType "MicrosoftMonitoringAgent" `
            -TypeHandlerVersion 1.0 `
            -Settings $PublicSettings `
            -ProtectedSettings $ProtectedSettings `
            -Location $location

        Set-AzVMExtension -ExtensionName "DependencyAgentWindows" `
            -ResourceGroupName $rgName `
            -VMName $vm.Name `
            -Publisher "Microsoft.Azure.Monitoring.DependencyAgent" `
            -ExtensionType "DependencyAgentWindows" `
            -TypeHandlerVersion 9.1 `
            -Settings $PublicSettings `
            -ProtectedSettings $ProtectedSettings `
            -Location $location

    }

    if($OsType -eq "Linux"){

        Set-AzVMExtension -ExtensionName "OMSExtension" `
            -ResourceGroupName $rgName `
            -VMName $vm.Name `
            -Publisher "Microsoft.EnterpriseCloud.Monitoring" `
            -ExtensionType "OmsAgentForLinux" `
            -TypeHandlerVersion 1.0 `
            -Settings $PublicSettings `
            -ProtectedSettings $ProtectedSettings `
            -Location $location

        Set-AzVMExtension -ExtensionName "DependencyAgentLinux" `
            -ResourceGroupName $rgName `
            -VMName $vm.Name `
            -Publisher "Microsoft.Azure.Monitoring.DependencyAgent" `
            -ExtensionType "DependencyAgentLinux" `
            -TypeHandlerVersion 9.1 `
            -Settings $PublicSettings `
            -ProtectedSettings $ProtectedSettings `
            -Location $location

    }

    else{

        Write-Host "OS Type :" -ForegroundColor Red -NoNewline
        Write-Host $OsType -ForegroundColor White -NoNewline
        Write-Host "  not supported " -ForegroundColor Red -NoNewline
    }

} 

Création d’alertes

              Pour optimiser la surveillance de la plateforme et pouvoir suivre au mieux les performances de nos VMs, nous pouvons créer des règles d’alerte dans Azur Monitor en se basant sur les insights des VMs. Ici nous allons créer une alerte nous permettant d’être notifié par mail dès lors que l’utilisation de la CPU d’une VM dépasse 80%.

Créer un groupe d’action

              Pour commencer nous devons créer un groupe d’action dans lequel nous allons indiquer quelle action devra être effectuée lors du déclenchement de l’alerte, dans notre exemple un envoie de mail.


# Add new email where alerts should be send
$email = New-AzActionGroupReceiver -Name "alerts-mail" -EmailReceiver -EmailAddress "perfAlert@infeeny.com"

# Add Action group
$act = Set-AzActionGroup -Name "performance alerts" -ResourceGroup $rgName -ShortName "perfalerts" -Receiver $email

#$act = Get-AzActionGroup -ResourceGroupName $rgSocleName -Name "plateform alerts Action Group"
$action = New-AzActionGroup -ActionGroupId $act.id

Ajouter une règle d’alerte

      Maintenant nous créons le critère de l’alerte avec la métrique que nous souhaitons surveiller. Puis on crée l’alerte à laquelle nous allons associer ce critère et le groupe d’action créé juste avant.


### Add metric Rule for CPU ###

#set alert criteria for CPU utilization 
$criteriacpu = New-AzMetricAlertRuleV2Criteria -MetricName "Percentage CPU" `
-TimeAggregation average `
-Operator GreaterThanOrEqual `
-Threshold 80 

#Add alert rule     
Add-AzMetricAlertRuleV2 -Name "Windows and Linux CPU Alerts" `
    -ResourceGroupName $rgName `
    -WindowSize 00:05:00 `
    -Frequency 00:01:00 `
    -TargetResourceScope $rg.ResourceId `
    -Condition $criteriacpu `
    -TargetResourceType microsoft.compute/virtualmachines `
    -TargetResourceRegion $location `
    -ActionGroup $action `
    -Severity 3 

Conclusion

              Pour conclure, grâce à la nouvelle fonctionnalité VM Insights d’Azure Monitor, nous avons un suivi et une vision complète des performances de nos VMs. Cette fonctionnalité nous apporte des Dashboards complets que nous pouvons customiser afin d’afficher les métriques qui nous sont le plus cohérentes.
              Dans cet article, vous avez toutes les informations nécessaires pour déployer la fonctionnalité VM Insights sur vos VMs Azure et générer des alertes vous permettant ainsi de réagir au plus vite en cas d’incident ou de surcharge. Ici nous avons choisi PowerShell mais il est tout à fait possible de déployer la solution via Terraform ou Azure ARM si vous faites de l’InfrasAsCode.

Voici le lien Github vers le script complet :

https://github.com/infeeny/VMInsights/blob/master/VMInsights.ps1

Comment automatiser le déploiement des ressources Azure avec Terraform à l'aide des Pipelines Azure DevOps.

TERRAFORM

Terraform est un outil open-source développé par HashiCorp, et utilisé pour provisionner et gérer des infrastructures IT dans le Cloud. Écrit en Go et fonctionnant en mode Infrastructure as a Code (IAC), il permet d’administrer une infrastructure grâce à du code au lieu de procéder à un ensemble d’opérations manuelles.

La force de Terraform est de reposer sur un langage de description d’infrastructure simple et lisible, on parle ici de HCL. L’approche IAC de Terraform permet de gérer le versioning d’une infrastructure en lui ajoutant ou retirant des composants.

Objectif

Dans cet article, nous allons voir :

  1. Comment définir une stack Terraform simple
  2. Comment utiliser conjointement Terraform et Azure DevOps dans l’optique de déployer l’infrastructure Azure, de manière automatique et continue.

Initialisation du projet

Voici la structure de fichier que nous allons adopter :

|– src\
|– terraform\
|– README.md

|– src\ will contain the sources of the Ansible Config,
|– terraform\ will contain all the deployment files.

1- Azure service principal

Rendons-nous dans Azure Active Directory et allons dans la partie App registrations.

  • Connectez-vous à votre compte Azure sur https://portal.azure.com
  • Cliquez sur le bouton Cloud Shell pour lancer le Cloud Shell.
  • La commande ci-dessous créera un principal de service avec le nom « SPName ». Remplacez la valeur et exécutez la commande dans le cloud shell.
az ad sp create-for-rbac --name SPName
  • À l’issu de cette commande, Azure CLI retournera un block JSON contenant les informations nécessaires a l’authentification du SP (client-id, client-secret)
abd###@Azure:~$ az ad sp create-for-rbac --name SPName
Changing "SPName" to a valid URI of "http://SPName", which is the required format used for service principal names
Creating a role assignment under the scope of "/subscriptions/##########-c1b3-####-8b7a-####9578ebf0"
  Retrying role assignment creation: 1/36
  Retrying role assignment creation: 2/36
  Retrying role assignment creation: 3/36
{
  "appId": "########-4611-4c09-9728-6ec9284314de",
  "displayName": "SPName",
  "name": "http://SPName",
  "password": "########",
  "tenant": "########-d76d-45cf-a7d2-ae98f73067ee"
}
  • Complétez le formulaire. Cliquez sur Vérifier la connexion pour vous assurer que les valeurs fonctionnent comme prévu. Cliquez sur OK une fois vérifié. Vous pourrez désormais référencer cette connexion à partir des tasks du pipeline.

2- TERRAFORM / INFRASTRUCTURE

|– src\
|– terraform\
____|– main.tf
____|– outputs.tf
____|– provider.tf
____|– variables.tf
____|– variables.tfvars
|– README.md

MAIN.tf file

data "azurerm_client_config" "current" {
}

locals {
  resource_group_name = "rg-${var.env}"

  tags = {
    env = "${var.env}"
  }
}

# ======================================================================================
# Resource Group
# ======================================================================================

resource "azurerm_resource_group" "resource_group" {
  location = "${var.location}"
  name     = "${var.env}-rg"
  tags     = "${local.tags}"
}

# ======================================================================================
# KeyVault
# ======================================================================================

resource "azurerm_key_vault" "key_vault" {
  name                        = "${var.env}-keyvault"
  location                    = "${azurerm_resource_group.app_resource_group.location}"
  resource_group_name         = "${azurerm_resource_group.app_resource_group.name}"
  tenant_id                   = "${data.azurerm_client_config.current.tenant_id}"
  enabled_for_disk_encryption = true

  sku {
    name = "standard"
  }

  access_policy {
    tenant_id = "${data.azurerm_client_config.current.tenant_id}"
    object_id = "${data.azurerm_client_config.current.object_id}"

    secret_permissions = [
      "get",
      "list",
      "set",
      "delete"
    ]
  }

  tags = "${local.tags}"
}

# ======================================================================================
# Network
# ======================================================================================

resource "azurerm_virtual_network" "vnet" {
  name                = "${var.vnet-name}"
  address_space       = "${var.address_space}"
  dns_servers         = [
           "192.168.0.1",
           "168.168.25.1",
        ]
  location            = "${azurerm_resource_group.resource_group.location}"
  resource_group_name = "${azurerm_resource_group.resource_group.name}"

  tags     = "${local.tags}"
}

resource "azurerm_subnet" "subnet" {
  name                 = "${var.subnet-name}"
  resource_group_name  = "${azurerm_resource_group.resource_group.name}"
  virtual_network_name = "${azurerm_virtual_network.vnet.name}"
  address_prefix       = "${var.address_prefix}"
  tags     = "${local.tags}"
}

resource "azurerm_network_interface" "vm-network-interface" {
  name                = "${var.vm-name}"
  location            = "${azurerm_resource_group.resource_group.location}"
  resource_group_name = "${azurerm_resource_group.resource_group.name}"
  
  ip_configuration {
    name                          = "vm-ipconfig"
    subnet_id                     = "${azurerm_subnet.subnet.id}"
    private_ip_address_allocation = "Dynamic"
  }
}
# ======================================================================================
# VM
# ======================================================================================

resource "azurerm_virtual_machine" "virtual-machine" {
  name                  = "${var.vm-name}"
  location              = "${azurerm_resource_group.resource_group.location}"
  resource_group_name   = "${azurerm_resource_group.resource_group.name}"
  network_interface_ids = ["${azurerm_network_interface.vm-network-interface.id}"]

  vm_size               = "DS3V2"

  storage_image_reference {
    publisher = "MicrosoftWindowsServer"
    offer     = "WindowsServer"
    sku       = "2016-Datacenter"
    version   = "latest"
  }
  storage_os_disk {
    name              = "vm-os-disk"
    caching           = "ReadWrite"
    create_option     = "FromImage"
    managed_disk_type = "Standard_LRS"
    
  }

  os_profile {
    computer_name  = "${var.computer-name}"
    admin_username = "${var.AdminUsername}"
    admin_password = "${var.AdminPassword}"
  }

}

PROVIDER.TF file

provider "azurerm" {
  version = "1.44.0"
}

terraform {
  required_version = "0.11.21"
  backend "azurerm" {
    storage_account_name = "shared$$_application_$$tfsa"
    container_name       = "terraform"
    key                  = "terraform-$$_environment_$$.tfstate"
    access_key           = "$$_tf_storage_account_key_$$"
  }
}

VARIABLES.TF file

data "azurerm_client_config" "current" {
}

provider "azurerm" {
    version = "=1.44.0"
    subscription_id  = "${data.azurerm_client_config.current.subscription_id}"               
    client_id        = "${data.azurerm_client_config.current.client_id}"                  
    tenant_id        = "${data.azurerm_client_config.current.tenant_id}"
    client_secret    = "$$_client_secret_$$"                 
    }

variable "env" {
  type = "string"
}
variable "location" {
  type = "string"
}
variable "address_space" {
  type = "string"
}
variable "subnet-name" {
  type = "string"
}
variable "address_prefix" {
  type = "string"
}

VARIABLES.TFVARS file

env = "$$_env_$$"
location = "$$_location_$$"
address_space = "$$_0.0.0.0/0_$$"
subnet-name = "$$_subnet-name_$$"
address_prefix = "$$_0.0.0.0/24_$$"

3- PIPELINE

Prérequis

Un compte GitHub, où vous pouvez gérer vos repository. Si vous n’en avez pas, vous pouvez créer un gratuitement.

Une organisation Azure DevOps. Si vous n’en avez pas, vous pouvez en créer une gratuitement. (Une organisation Azure DevOps est différente de votre organisation GitHub. Par best-practices, donnez-leur le même nom)

Commençons par créer notre premier pipeline !

1- Azure DevOps – BUILD

Créons un nouveau Build Pipeline, puis cliquer sur Use the visual designer pour avoir le mode visuel.

Pour ce lab, nous utiliserons la branche master.

commencer par un Empty job

Ensuite, ajoutez Publish Artifact. Cette étape est utilisée pour incorporer les fichiers Terraform dans l’artifact.

Ensuite, spécifiez le dossier ou le chemin du fichier à publier. Il peut s’agir d’un full path ou d’un chemin relatif à la racine du repository.

Enfin, procédons au lancement de notre première build. Si tout se passe bien, nous obtenons l’artifact suivant :

2- Azure DevOps – RELEASE

Créons maintenant un nouveau Release Pipeline, pour ce faire, nous allons commencer à partir d’un modèle de travail vide Empty job template.

Renommons la première étape DEV.

Pour utiliser Terraform, nous avons besoin de :

  1. créer son backend sur Azure Storage (Blob),
  2. récupérer la Key de ce Storage et de l’injecter dans les variables pour pouvoir écrire/lire dans le Blob.

Première étape, ajoutons une étape de type Azure CLI pour la création du backend :

az group create --location $(location) --name "rg-$(env)-tfstate" 

az storage account create --name "sa$(env)tfstate$(location)" --resource-group "rg-$(env)-tfstate" --location $(location) --sku Standard_LRS  --tags 

az storage container create --name "terraform" --account-name "sa$(env)tfstate$(location)"

Next, add a second job Azure Powershell to get the storage account access_key

$key = (Get-AzStorageAccountKey -ResourceGroup "rg-$(env)-tfstate" -Name "sa$(env)tfstate$(location)").Value[0]

Write-Host "##vso[task.setvariable variable=tf_storage_account_key]$key"

The following two steps allow you to replace the tokens ($$_value_$$) present in the Terraform files.

Ensuite, ajoutons les tasks terraform:

  • install terrafrom ()
  • init
  • validate
  • plan
  • apply

Add Pipiline variables

Link a KeyVault to your DevOps pipeline project

prochains articles :

  1. Configurer une ressource (AD serveur) a l’aide d’Ansible-DevOps en one shot
  2. Configurer une ressource (AD serveur) a l’aide du DSC-DevOps en one shot

L&L Kubernetes et AKS

Retrouvez notre Expert Christophe, dans une vidéo sur Kubernetes et AKS. La vidéo est Level 100, accessible à tous. URL sur Youtube: ici

Contenu: Il s’agit de prendre un projet Web API sous Visual Studio 2019 avec support Docker (container Linux) et de construire l’image Docker en local. Ensuite on pousse cette image dans une registry ACR afin de faire un déploiement dans un cluster AKS. Ensuite, on aborde kubectl, l’outil console de Kubernetes.

Pour réaliser toutes les opérations techniques, un HOWTO est à télécharger sur https://infeeny.com/net-core-sous-aks/

Développement Web ASP .NET Core

Bonjour, dans cet article, nous allons vous présenter la solution eShopWeb, voici comment va se décomposer l’article :

    • Architecture monolithique
    • Design Pattern MVC
    • Entity Framework Core
    •  eShopWeb
      • Introduction
      • Explication de la fonctionnalité Add to Basket
      • Explication de la fonctionnalité Checkout

Architecture monolithique

Le terme monolithique est plutôt utilisé lorsque l’on parle de conception d’application (ou architecture) et représente le modèle dit « traditionnel » d’une application. On peut considérer ce genre d’architecture comme un bloc unifié (contrairement aux micro-services).

Néanmoins, on peut mettre différentes couches de données (par exemple du MVC, mais nous reviendrons sur l’explication de se terme plus loin dans cet article). Ce qui signifie que les différents composants sont intrinsèquement connectés les uns aux autres et sont la plupart du temps dépendant de chacune des couches existantes.

L’inconvénient principal est lors de la mise à jour d’un élément, il faut alors réécrire une bonne partie de l’application (si ce n’est son entièreté). Par opposition, l’architecture monolithique permet un meilleur rendement que l’architecture micro-services. Mais surtout l’aspect monolithique permet de facilité les tests et le débogage car il y a moins d’éléments à prendre en compte.

Patron de conception : Modèle – Vue – Contrôleur (MVC)

Ce qu’on appelle en français un patron de conception est appelé en anglais design pattern. Et celui du MVC permet de séparer la logique du code :

  • Modèle : Un modèle permet de gérer les données du site. Il va donc chercher les informations dans la base de données, les organiser et les assembler pour ensuite être traité par le Contrôleur.
  • Vue : Une vue va comme son nom l’indique s’occuper de l’affichage. Il n’y a quasiment aucun calcul dans cette partie car son seul but est de récupérer des variables pour savoir ce qui va être affiché.
  • Contrôleur : Un contrôleur va gérer la logique du code. Il sert d’intermédiaire entre le modèle et la vue. Globalement, il va demander au modèle les données et les analyser puis il renvoie le texte qu’il faut afficher à la vue.

On peut, en complément du Contrôleur, avoir une couche que l’on va nommer communément Service, qui va se charger de la récupération de données pour une API par exemple.

Entity Framework Core

Entity Framework Core est un ORM créé par Microsoft, il vous permet d’effectuer des opérations CRUD sans avoir besoin d’écrire des requêtes SQL.

Pour reprendre à la base : qu’est-ce qu’un ORM ?

ORM signifie Object Relational Mapping ou Mapping Objet Relationnel en français. C’est une couche supplémentaire à notre application.

Mais qu’est-ce que ça signifie concrètement : que ça se place entre un programme applicatif et une base de données relationnelle afin de simuler une base de données orientée objet. On va donc associer une classe et une table et pour chacun des attributs de la classe qui vont correspondre à un champ de la table associée.

Avantages

  • Réduction de la quantité de code est réduite et que l’on gagne en homogénéité avec le reste du code (pour les langages orientés objets).
  • On va pouvoir travailler directement avec des objets complexes.
  • Plus besoin d’écrire nos requêtes SQL.
  • Moins de travail pour les développeurs

Inconvénients

L’utilisation d’ORM, induit une couche logicielle supplémentaire ce qui forcément nuit aux performances de l’application et rend particulièrement délicate la maintenance de l’application. Ainsi que la durée de vie de l’application.

Modeling

Entity Framework Core va via une commande « mapper » des classes complexes. Il va donc faire une requête à la base de données et remplir les données de nos classes associé au même table.

Les classes à remplir s’appellent des Modèles. Voici un exemple dans la solution eShopWeb :

namespace Microsoft.eShopWeb.Web.ViewModels
{
  public class CatalogItemViewModel
  {
     public int Id { get; set; }
     public string Name { get; set; }
     public string PictureUri { get; set; }
     public decimal Price { get; set; }
  }
}

Comme vous pouvez le voir, ce Modèle correspond aux informations relatives à un objet présent dans le catalogue.

Maintenant, voici l’objet Catalog qui contient tout les items et d’autres informations :

using Microsoft.AspNetCore.Mvc.Rendering; using System.Collections.Generic; namespace Microsoft.eShopWeb.Web.ViewModels {   
  public class CatalogIndexViewModel   
  {     
    public IEnumerable<CatalogItemViewModel> CatalogItems { get; set; } public IEnumerable<SelectListItem> Brands { get; set; }     
    public IEnumerable<SelectListItem> Types { get; set; }     
    public int? BrandFilterApplied { get; set; }     
    public int? TypesFilterApplied { get; set; }     
    public PaginationInfoViewModel PaginationInfo { get; set; }  
 
  } 
}

Pour pouvoir le remplir (binding), nous allons donc maintenant voir un nouvel exemple :

using Microsoft.eShopWeb.ApplicationCore.Entities;
using System.Collections.Generic;
using System.Threading.Tasks; namespace Microsoft.eShopWeb.ApplicationCore.Interfaces {   
  public interface IAsyncRepository<T> where T : BaseEntity, IAggregateRoot   
  {     
    Task<T> GetByIdAsync(int id);     
    Task<IReadOnlyList<T>> ListAllAsync();     
    Task<IReadOnlyList<T>> ListAsync(ISpecification<T> spec);     
    Task<T> AddAsync(T entity);
    Task UpdateAsync(T entity);     
    Task DeleteAsync(T entity);     Task<int> CountAsync(ISpecification<T> spec);   
  } }

Ci-dessus, c’est là où nous faisons appel à EntityFrameworkCore.

Et dans le Service : CatalogViewModelService.cs

public async Task<CatalogIndexViewModel> GetCatalogItems(int pageIndex, int itemsPage, int? brandId, int? typeId) {   
  _logger.LogInformation("GetCatalogItems called.");   
  var filterSpecification = new CatalogFilterSpecification(brandId, typeId);
  var filterPaginatedSpecification =   new CatalogFilterPaginatedSpecification(itemsPage * pageIndex, itemsPage, brandId, typeId);   // the implementation below using ForEach and Count. We need a List.   
  var itemsOnPage = await _itemRepository.ListAsync(filterPaginatedSpecification);   var totalItems = await _itemRepository.CountAsync(filterSpecification);   var vm = new CatalogIndexViewModel()   
{     
  CatalogItems = itemsOnPage.Select(i => new CatalogItemViewModel()     
  {        
    Id = i.Id,        
    Name = i.Name,       
    PictureUri = _uriComposer.ComposePicUri(i.PictureUri),        
    Price = i.Price     
  }),     
  
  Brands = await GetBrands(),     
  Types = await GetTypes(),     
  BrandFilterApplied = brandId ?? 0,     
  TypesFilterApplied = typeId ?? 0,     
  PaginationInfo = new PaginationInfoViewModel()    
  {       
    ActualPage = pageIndex,       
    ItemsPerPage = itemsOnPage.Count,       
    TotalItems = totalItems,       
    TotalPages = int.Parse(Math.Ceiling(((decimal)totalItems / itemsPage)).ToString())     
  }   
};   
  vm.PaginationInfo.Next = (vm.PaginationInfo.ActualPage == vm.PaginationInfo.TotalPages - 1) ? "is-disabled" : "";   
  vm.PaginationInfo.Previous = (vm.PaginationInfo.ActualPage == 0) ? "is-disabled" : "";   
  return vm; }

 

Providers

Un provider n’est ni plus ni moins qu’une librairie utilisable. Dans notre cas, celle qui nous intéresse particulièrement et dont on va parler est la librairie InMemory qui est un Fournisseur en Mémoire.

InMemory Provider

Ce fournisseur est utile lorsque l’on souhaite tester des composants en utilisant quelque chose qui se rapproche de la connexion à la base de données réelle, sans les frais des opérations de la base de données réelle.

L’avantage de ce fournisseur en mémoire et que l’on peut tester notre code par rapport à une base de données en mémoire au lieu de devoir en installer une et de la configurer.

Solution eShopWeb

Nous allons maintenant voir plus en détail cette solution et nous allons nous pencher sur les deux fonctionnalités majeures :

  • Add to Basket
  • Checkout

Add to Basket

Le « Add to Basket » comme son nom l’indique, vous permet d’ajouter un article dans votre panier.

eshopweb.PNG

Accueil du site

Voilà à quoi ressemble le site eShopWeb. Une fois que vous cliquez sur Add to Basket, vous êtes directement redirigé vers votre panier.  via l’URL : https://localhost:44315/Basket

Capturebasket.PNG

Que se passe-t-il au niveau du code ?

L’image représentant l’accueil du site est dans le code, lié au fichier _product.cshtml qui lorsqu’un utilisateur clique sur ADD TO BASKET il sera redirigé ver l’URL suivante : http://localhost:port/Basket

Cette URL correspond au fichier Index.cshtml qui est couplé au fichier Index.cshtml.cs et c’est ce fichier cshtml.cs qui va posséder la « logique » de la page avec une méthode OnPost.

public async Task<IActionResult> OnPost(CatalogItemViewModel productDetails) {   
    if (productDetails?.Id == null)   
    {     
        return RedirectToPage("/Index");   
    }   

    await SetBasketModelAsync(); //Vérifie si l'on est connecté.   
    await _basketService.AddItemToBasket(BasketModel.Id, productDetails.Id, productDetails.Price); //Ajout de l'objet au panier.   
    await SetBasketModelAsync();  
    return RedirectToPage(); }

Dans cette méthode OnPost, on peut voir :

  • Une condition if, afin de vérifier si l’ID du produit n’existe pas
    • Si cette condition se vérifie, l’utilisateur sera redirigé vers l’URL http://localhost:port/Index
    • Sinon, on vérifie d’abord que l’utilisateur est connecté grâce à SetBasketModelAsync()
  • Ce SetBasketModelAsync() va quant à lui, vérifier si l’utilisateur est connecté et s’il a déjà un panier de fait sinon l’utilisateur n’est pas encore connecté mais possède un panier avec les éléments qu’il aura ajouté dedans.
  • Suite à cela, on va ajouter le produit dans le panier en prenant en compte, l’id du panier, l’id du produit ainsi que le prix de celui-ci en passant par la classe BasketService :
public async Task AddItemToBasket(int basketId, int catalogItemId, decimal price, int quantity = 1) //Cette méthode ajoute le produit en premier. {   
    var basket = await _basketRepository.GetByIdAsync(basketId); //Vérifie à quel panier il doit l'ajouter.   
    basket.AddItem(catalogItemId, price, quantity); //Appel de la méthode dans Basket.cs   
    await _basketRepository.UpdateAsync(basket); }

Pour rappel, la variable _basketRepository basé sur la classe BasketRepository correpond à notre Entity Framework Core.

    • Ce même Service (BasketService) va tout d’abord Get le panier via l’id passé en paramètre (le nom du paramètre : basketId) et le stocker dans la variable basket (qui correspondra à une variable initialisée avec la classe Basket)
    • Puis on va ajouter un produit via la méthode AddItem que nous allons voir par la suite et qui prend en paramètres l’id du catalogue, le prix du produit et la quantité (par défaut initialisée à 1).
    • La dernière ligne va nous permettre de charger notre panier dans la base de donnée.
public void AddItem(int catalogItemId, decimal unitPrice, int quantity = 1) //méthode d'ajout 
{
  if (!Items.Any(i => i.CatalogItemId == catalogItemId))
    {
       _items.Add(new BasketItem(catalogItemId, quantity, unitPrice));
       return;
    }
  var existingItem = Items.FirstOrDefault(i => i.CatalogItemId == catalogItemId);
  existingItem.AddQuantity(quantity);
}
  •  le If va nous permettre de savoir si le produit se trouve déjà dans notre liste de produit.
  • Si non, nous entrons dans le If et nous l’ajoutons.
  • Si oui, nous allons simplement mettre à jour la quantité de ce produit.

 

Passons maintenant à la partie Paiement (Checkout)

Il existe deux cas pour cette partie :

  • Soit vous êtes connecté
    • Le bouton CHECKOUT dans le fichier Index.cshtml va vous emmener sur le fichier Checkout.cshtml.
      • Ce fichier est lié au fichier Checkout.cshtml.cs qui va s’occuper de toute la logique.
      • La méthode dans Checkout.cshtml.cs qui nous intéresse est la méthode OnPost :
public async Task<IActionResult> OnPost(Dictionary<string, int> items) {   
    await SetBasketModelAsync();   
    await _basketService.SetQuantities(BasketModel.Id, items);   
    await _orderService.CreateOrderAsync(BasketModel.Id, new Address("123 Main St.", "Kent", "OH", "United States", "44240"));   
    await _basketService.DeleteBasketAsync(BasketModel.Id);   
    return RedirectToPage(); 
}
        • La méthode SetBasketModelAsync() comme précédemment va vérifier si vous êtes connectés ou non en tant qu’utilisateur
        • Le _basketService.SetQuantities() va set le nombre d’articles présent dans notre panier
        • Le _orderService.CreateOrderAsync() fait appel au service OrderService et permet l’ajout de notre commande (on va le détailler comment cela fonctionne un peu plus tard).
        • Le _basketService.DeleteBasketAsync() va détruire le panier dans la base de donnée.
    • Pour revenir au _orderService.CreateOrderAsync() :
public async Task CreateOrderAsync(int basketId, Address shippingAddress) { var basket = await _basketRepository.GetByIdAsync(basketId);   Guard.Against.NullBasket(basketId, basket);
var items = new List<OrderItem>();
foreach (var item in basket.Items)
{
var catalogItem = await _itemRepository.GetByIdAsync(item.CatalogItemId);     var itemOrdered = new CatalogItemOrdered(catalogItem.Id, catalogItem.Name, _uriComposer.ComposePicUri(catalogItem.PictureUri));
var orderItem = new OrderItem(itemOrdered, item.UnitPrice, item.Quantity);     items.Add(orderItem); }
var order = new Order(basket.BuyerId, shippingAddress, items);
await _orderRepository.AddAsync(order);
}

Que fait cette méthode ?

  • On get d’abord le panier
  • Ensuite on regarde si le panier est null
  • Nous créons une liste d’item à commander
  • Dans la boucle nous allons remplir cette liste en récupérant les éléments se trouvant dans notre panier
  • Nous allons créer un nouvel objet Order
  • Et l’ajouter dans la base de donner (appel de OrderRepository.AddAsync())

MVC : Comment les interactions sont faites

order.PNG

Mes commandes – Images

 

Cette page est la représentation graphique de la View (vue) : MyOrders.cshtml

@model IEnumerable<OrderViewModel>
@{
ViewData["Title"] = "My Order History";
}

<div class="esh-orders">
<div class="container">
<h1>@ViewData["Title"]</h1>
<article class="esh-orders-titles row">
<section class="esh-orders-title col-xs-2">Order number</section>
<section class="esh-orders-title col-xs-4">Date</section>
<section class="esh-orders-title col-xs-2">Total</section>
<section class="esh-orders-title col-xs-2">Status</section>
<section class="esh-orders-title col-xs-2"></section>
</article>
@if (Model != null && Model.Any())
{
@foreach (var item in Model)
{
<article class="esh-orders-items row">
<section class="esh-orders-item col-xs-2">@Html.DisplayFor(modelItem => item.OrderNumber)</section>
<section class="esh-orders-item col-xs-4">@Html.DisplayFor(modelItem => item.OrderDate)</section>
<section class="esh-orders-item col-xs-2">$ @Html.DisplayFor(modelItem => item.Total)</section>
<section class="esh-orders-item col-xs-2">@Html.DisplayFor(modelItem => item.Status)</section>
<section class="esh-orders-item col-xs-1">
<a class="esh-orders-link" asp-controller="Order" asp-action="Detail" asp-route-orderId="@item.OrderNumber">Detail</a>
</section>
<section class="esh-orders-item col-xs-1">
@if (item.Status.ToLower() == "submitted")
{
<a class="esh-orders-link" asp-controller="Order" asp-action="cancel" asp-route-orderId="@item.OrderNumber">Cancel</a>
}
</section>
</article>
}
}
</div>
</div>

Cette View est directement lié au Contrôleur : OrderController, plus particulièrement à la méthode MyOrders :

[HttpGet()]
public async Task<IActionResult> MyOrders()
{
var viewModel = await _mediator.Send(new GetMyOrders(User.Identity.Name));

return View(viewModel);
}

Comme nous pouvons le voir ici, la première ligne correspond au contrôle de données (ici, nous récupérons la liste des commandes dans la base de données). Puis nous retournons la vue de notre Contrôleur (l’image Mes commandes – Images ci-dessus).

Si nous cliquons sur un des boutons DETAIL, nous aurons accès au détail du produit sélectionné (la sélection se fait par l’id du produit) :

<section class="esh-orders-item col-xs-1">
<a class="esh-orders-link" asp-controller="Order" asp-action="Detail" asp-route-orderId="@item.OrderNumber">Detail</a>
</section>

L’appel à Detail dans le fichier order.cshtmlIci, on va appeler la méthode de l’OrderController s’appelant Detail.

[HttpGet("{orderId}")]
public async Task<IActionResult> Detail(int orderId)
{
var viewModel = await _mediator.Send(new GetOrderDetails(User.Identity.Name, orderId));

if (viewModel == null)
{
return BadRequest("No such order found for this user.");
}

return View(viewModel);
}

On peut observer que dans le Contrôleur, nous récupérons le détail de la commande. Et nous retournons la bonne vue associée :

@model OrderViewModel
@{
ViewData["Title"] = "My Order History";
}
@{
ViewData["Title"] = "Order Detail";
}

<div class="esh-orders-detail">
<div class="container">
<section class="esh-orders-detail-section">
<article class="esh-orders-detail-titles row">
<section class="esh-orders-detail-title col-xs-3">Order number</section>
<section class="esh-orders-detail-title col-xs-3">Date</section>
<section class="esh-orders-detail-title col-xs-2">Total</section>
<section class="esh-orders-detail-title col-xs-3">Status</section>
</article>

<article class="esh-orders-detail-items row">
<section class="esh-orders-detail-item col-xs-3">@Model.OrderNumber</section>
<section class="esh-orders-detail-item col-xs-3">@Model.OrderDate</section>
<section class="esh-orders-detail-item col-xs-2">$@Model.Total.ToString("N2")</section>
<section class="esh-orders-detail-item col-xs-3">@Model.Status</section>
</article>
</section>

<section class="esh-orders-detail-section">
<article class="esh-orders-detail-titles row">
<section class="esh-orders-detail-title col-xs-12">Shipping Address</section>
</article>

<article class="esh-orders-detail-items row">
<section class="esh-orders-detail-item col-xs-12">@Model.ShippingAddress.Street</section>
</article>

<article class="esh-orders-detail-items row">
<section class="esh-orders-detail-item col-xs-12">@Model.ShippingAddress.City</section>
</article>

<article class="esh-orders-detail-items row">
<section class="esh-orders-detail-item col-xs-12">@Model.ShippingAddress.Country</section>
</article>
</section>

<section class="esh-orders-detail-section">
<article class="esh-orders-detail-titles row">
<section class="esh-orders-detail-title col-xs-12">ORDER DETAILS</section>
</article>

@for (int i = 0; i < Model.OrderItems.Count; i++)
{
var item = Model.OrderItems[i];
<article class="esh-orders-detail-items esh-orders-detail-items--border row">
<section class="esh-orders-detail-item col-md-4 hidden-md-down">
<img class="esh-orders-detail-image" src="@item.PictureUrl">
</section>
<section class="esh-orders-detail-item esh-orders-detail-item--middle col-xs-3">@item.ProductName</section>
<section class="esh-orders-detail-item esh-orders-detail-item--middle col-xs-1">$ @item.UnitPrice.ToString("N2")</section>
<section class="esh-orders-detail-item esh-orders-detail-item--middle col-xs-1">@item.Units</section>
<section class="esh-orders-detail-item esh-orders-detail-item--middle col-xs-2">$ @Math.Round(item.Units * item.UnitPrice, 2).ToString("N2")</section>
</article>
}
</section>

<section class="esh-orders-detail-section esh-orders-detail-section--right">
<article class="esh-orders-detail-titles esh-basket-titles--clean row">
<section class="esh-orders-detail-title col-xs-9"></section>
<section class="esh-orders-detail-title col-xs-2">TOTAL</section>
</article>

<article class="esh-orders-detail-items row">
<section class="esh-orders-detail-item col-xs-9"></section>
<section class="esh-orders-detail-item esh-orders-detail-item--mark col-xs-2">$ @Model.Total.ToString("N2")</section>
</article>
</section>
</div>
</div>

Fichier .cshtml se traduisant en élément graphique par l’image ci-dessous :

order_details.PNG

Détail du produit Mug

Il en va de même pour toutes les pages, chaque pages fonctionnant de la même façon. Notre Contrôleur va gérer nos données (Modèle) et retourner la Vue correspondante au Contrôleur.

 

Conclusion

Ce qu’on peut tirer de ce projet, est l’application d’une architecture monolithique en opposition avec le eShopOnContainers qui se base sur les micro-services.

Ce sont deux approches différentes et qui ont chacune leurs avantages et leurs inconvénients.

Néanmoins ces derniers temps, les entreprises privilégient les micro-services avec Docker et le concept de conteneurisation.

Article écrit par :

  • Julie LACOGNATA <julie.lacognata@infeeny.com>
  • Kévin ANSARD <kevin.ansard@infeeny.com>

Déploiement d’un projet Web API .NET Core 3.1 avec Azure Kubernetes Services (AKS)

Nous avons eu l’occasion de travailler à deux reprises avec Kubernetes.

Deux univers bien distinct : Windows et Linux

Ce qu’il faut savoir, c’est que Kubernetes ne fonctionne pas sous Windows dans son plus simple appareil, il faut donc utiliser Linux pour pouvoir le découvrir et pour l’apprendre concrètement.

Si vous voulez l’utiliser sous Windows, il vous faudra utiliser des services externes type AKS. Néanmoins, pour ma part, je trouve que la compréhension d’un outil via ce genre de plateforme est assez biaisé, car trop « magique”. Cela demande une certaines rigueur,une curiosité et un intérêt différent que si vous le faisiez directement sous Linux.

Prérequis pour ce tutoriel

  • Visual Studio 2019 (ou Visual Studio Code)
  • Internet (pour accéder au portail Azure)
  • Powershell
  • Helm
  • Chocolatey
  • Docker
  • Azure-CLI

Création d’une Web API .NET Core 3.1 avec un container Docker sous Linux

Aujourd’hui, nous allons voir ensemble comment créer une Web API sous .NET Core 3.1 et la déployer sous Azure.

Ouvrez votre Visual Studio et créer un nouveau projet ASP .NET Core Application.

Choisissez ensuite API (faites attention à bien avoir sélectionné .NET Core ainsi que la version 3.1) puis dans le panneau de configuration à droite dans la partie “Advanced” de cocher “Enable Docker Support” et de choisir Linux.

1_HIycDu3ImbMFl2B6aDqQbA.png

Choix de la création de projet via Visual Studio et support Docker avec des containers Linux.

L’API par défaut que crée Microsoft, s’appelle WeatherForecast, et dans notre cas nous avons choisis de nommer notre projet WeatherForecastLinux (pour les personnes manquant d’inspiration pour le nommage, c’est cadeau…).

On va donc constater qu’un fichier Dockerfile est présent. Si vous pratiquez Docker ou que vous avez quelques bases dessus vous connaissez donc son utilité. Pour expliquer pourquoi il est présent, vous vous doutez fortement que c’est dû au fait qu’on ait coché la case de support de Docker lors de la création du projet.

Pour les personnes ne sachant pas ce qu’est un Dockerfile, voici une définition succincte : c’est un fichier texte contenant des instructions sur la façon de construire une image Docker.

Voilà à quoi ressemble notre Dockerfile auto-généré :

FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443
FROM mcr.microsoft.com/dotnet/core/sdk:3.1-buster AS build
WORKDIR /src
COPY [“WeatherForecastLinux.csproj”, “”]
RUN dotnet restore “./WeatherForecastLinux.csproj”
COPY . .
WORKDIR “/src/.”
RUN dotnet build “WeatherForecastLinux.csproj” -c Release -o /app/build

FROM build AS publish
RUN dotnet publish “WeatherForecastLinux.csproj” -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY — from=publish /app/publish .
ENTRYPOINT [“dotnet”, “WeatherForecastLinux.dll”]

Si vous souhaitez vérifier que votre application se lance correctement, je vous suggère de cliquer sur :

1_FzBBfH9h-p7ucjzNtQugBw.png

Le fait de cliquer sur Docker, va permettre de build et de run le Dockerfile et donc de créer l’image Docker.

Nous allons maintenant ouvrir une fenêtre PowerShell :

  • Soit vous l’ouvrez directement dans le dossier de votre projet
  • Soit vous vous placez au bon endroit pour être au niveau de votre Dockerfile

Le build et le run précédent vous on créée une image, pour vérifier le nom de celui-ci vous pouvez directement taper la commande :

docker ps -a

Ou

docker images

Picture1.png

Dans notre cas, l’image qui nous intéresse est : weatherforecastlinux

 

Maintenant que toutes les fondations sont posées, nous pouvons maintenant passer au déploiement.

Azure Kubernetes Service (AKS)

Tout d’abord, assurez-vous d’avoir accès au Portail Azure, si ce n’est pas le cas créer vous un compte via une adresse Microsoft, et utiliser les 150€ gratuit fournit de base par Microsoft (si vous êtes vigilant dans vos différentes opérations avec Azure, vous ne devriez pas utiliser tout ce crédit en un coup).

Petit disclaimer : il y aura forcément un aspect « magique » ou un aspect de confusion pour les nouveaux arrivants sur Azure (et parfois même pour les plus anciens…) car Azure est très vaste, mais ne vous inquiétez pas, c’est tout à fait normal !

Il nous faudra tout d’abord installer Azure-CLI sur notre poste, afin d’utiliser la commande az (qui nous permet de faire de l’Azure directement via notre fenêtre Powershell). Pour se faire, ouvrir Powershell en mode administrateur et utiliser la commande suivante :

Invoke-WebRequest -Uri  -OutFile .\AzureCLI.msi; Start-Process msiexec.exe -Wait -ArgumentList ‘/I AzureCLI.msi /quiet’

Redémarrer votre Powershell pour que la commande puisse être active. Si cela ne fonctionne pas chez vous, installez le .msi directement sur le site et installez-le classiquement.

Il vous faut maintenant vous connecter, pour que votre instance et les informations soient bien raccorder à votre Portail Azure :

az login -u votremail@mail.com -p votremotdepasse

Kubernetes

Kubernetes est un orchestrateur. On peut dire que c’est un ensemble de services réseaux qui permet de lancer des pods Docker en cluster avec une gestion de Load Balancing.

Pods

Les pods correspondent au processus en cours d’exécution et encapsulent un ou des conteneurs applicatifs. Ce sont des instances uniques, cela signifie qu’ils possèdent :

  • Une IP unique
  • Un fichier qui indique comment le conteneur doit être exécuté
  • Des ressources de stockage

Ce qu’il faut retenir, si nous devions résumer un peu tout ça, c’est que les pods peuvent correspondre à une application ayant sa propre mémoire, sa propre IP. Néanmoins, un pod a une durée de vie définit et ne sera pas en mesure de se relancer automatiquement de lui-même.

Load Balancing

Ou répartition de charge en français, désigne un processus de répartition d’un ensemble de tâche sur un ensemble de ressources. Le but étant de rendre le traitement global plus efficace, en permettant d’optimiser le temps de réponse pour chaque tâche tout en évitant un surcharge inégale des nœuds de calculs.

Création d’un Resource Group Azure : WeatherForecastAPI_RG

Resource Group (ou RG)

Un resource group ou groupe de ressources est en quelque sorte un conteneur dit « logique » ayant pour objectif de regrouper différentes entités (Web API, VM, Base de données, etc…). Toutes les entités présentes au sein du groupe sont alors accessibles.

Dans notre cas, cela va nous permettre de créer un cluster et de déployer notre application directement dans ce RG.

Pour pouvoir créer un groupe de ressources en ligne de commande :

az group create --name WeatherForecastAPI_RG --location francecentral

La réponse à cette commande devra vous apparaître sous cette forme :

{
  "id": "/subscriptions/caf29a4f-0f21-45d9-b52e-f1e0c0b8e4be/resourceGroups/WeatherForecastAPI_RG",
  "location": "francecentral",
  "managedBy": null,
  "name": "WeatherForecastAPI_RG",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Comme nous pouvons le voir, nous retrouvons le nom de notre Resource Group ainsi que son state (Succeeded). Nous pouvons également voir que nous avons bien la localisation précédemment choisie qui nous est retournée.

Build de l’image Docker

Docker

Docker est une plateforme de conteneurisation. Et les conteneurs ressemblent en tout point à des machines virtuelles ou seul le système d’exploitation ou OS aura été virtualisé. Docker permet de regrouper tout le nécessaire de notre application et est donc qualifiée de compacte, puissante et innovante avec une scalabilité importante.

Nous allons donc builder l’image dont on parle un peu plus haut : weatherforecastlinux mais cette fois nous allons récupérer le tag avec le mot clef -t (que vous pouvez également voir sur la capture d’écran plus  haut).

docker build -t weatherforecastlinux:dev .

Si tout se déroule correctement vous êtes censés avoir une mention de toutes les étapes présente dans votre Dockerfile ainsi que la notion Successfully

Création de la registry WEFCACR dans Azure Container Registry (ACR)

Registry

Une registry est une sorte de « repository » d’images. Grossièrement on peut dire que c’est un espace de stockage d’images.

Pour pouvoir la créer sous Azure en ligne de commande :

az acr create --resource-group WeatherForecastAPI_RG --name WEFCACR --sku Basic

La commande ci-dessus permet de créer une registry, en spécifiant le Resource Group ainsi que le nom que l’on souhaite donner à la registry (ici WEFACR). Le –sku Basic est un élément sans importance, d’ailleurs si vous ne l’indiquez pas, par défaut il vous sera rajouté.

La commande suivante, vous permet de lister les différentes registry.

az acr list --resource-group WeatherForecastAPI_RG --query "[].{acrLoginServer:loginServer}" --output table

Enfin la commande az acr login, vous permet comme son nom l’indique de vous connecter à Azure Container Registry (ACR).

az acr login --name WEFCACR

Tag de l’image Docker avec la registry wefcacr.azurecr.io

La commande ci-dessous, vous permet de taguer votre image docker en lui donnant un nouveau nom :

docker tag weatherforecastlinux:dev wefcacr.azurecr.io/weatherforecast:dev

Se connecter dans la registry WEFCACR

az acr login --name WEFCACR

 

Push de l’image Docker dans WEFCACR

On va push l’image dans la registry en faisant un docker push et en spécifiant le nom de la registry (que l’on peut retrouver à l’aide de la commande az acr list) et en spécifiant le nom de l’image ainsi que son tag.

docker push wefcacr.azurecr.io/weatherforecast:dev

 

Création du cluster AKS WEFCACRCluster

Cluster

Un cluster Azure peut être considéré comme une « grappe », il peut utiliser des nœuds et exécuter des conteneurs.

Allez sur le portail Azure et dans la barre de rechercher, taper Kubernetes services :

Kubernetes_services.png

Cliquez sur le bouton Add, vous atteindrez cette page :

Picture2.png

Puis cliquer sur Ajouter, votre Cluster mettra un certains temps à se créer ce qui est tout à fait normal. Il vous faudra donc patienter deux minutes grand maximum, avant de lancer la commande suivante :

Connexion au cluster WEFCACRCluster

az aks get-credentials --resource-group WeatherForecastAPI_RG --name WEFCACRCluster

permet d’associer le ressource group a notre cluster

Liaison entre le cluster AKS et la registry

az aks update -n WEFCACRCluster -g WeatherForecastAPI_RG --attach-acr WEFCACR

ici nous attachons notre cluster a notre registry en spécifiant a qu’elle ressources groupe notre cluster appartient

Installation de Helm sous Windows

Helm est un gestionnaire de paquets pour Kubernetes qui va permettre d’installer et de gérer le cycle de vie de nos applications.

Pour l’installer sous Windows, il vous faut installer Chocolatey et pour se faire voici la première commande permettant d’installer Chocolatey (gestionnaire de paquets pour Windows qui vous permet d’installer ou de désinstaller des applications grâce à la commande choco).

Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
  • Installation de Helm via Chocolatey
choco install kubernetes-helm

 

Création des fichiers avec Helm

Nous allons créer un dossier chart, qui sera architecturé de la façon suivante :

  • chart/
    • Chart.yaml
    • values.yaml
    • templates/
      • deployment.yaml
      • service.yaml

Architecture du fichier Chart.yaml

name: aspnet3-demo
version: 1.0.0

Architecture du fichier values.yaml

environment: development

apphost: k8s

label:
name: dockerwithlinux

container:
name: dockerwithlinux
pullpolicy: IfNotPresent
image: jlaacr02.azurecr.io/app1
tag: v1
port: 80
replicas: 3

service:
port: 8888
#type: ClusterIP
type: NodePort

Ce fichier va nous permettre de définir quelle image nous allons pull et quel tag utiliser, ainsi que les port que nous voulons.

Architecture du fichier templates/deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-deployment
  labels:
    app: {{ .Values.label.name }}
spec:
  replicas: {{ .Values.replicas }}
  selector:
    matchLabels:
      app: {{ .Values.label.name }}
  template:
    metadata:
      labels:
        app: {{ .Values.label.name }}
        environment: {{ .Values.environment }}
    spec:
      containers:
        - name: {{ .Values.container.name }}
          image: {{ .Values.container.image }}:{{ .Values.container.tag }}
          imagePullPolicy: {{ .Values.container.pullPolicy }}
          ports:
            - containerPort: {{ .Values.container.port }}
          env:
            - name: apphost
              value: {{ .Values.apphost }}
            - name: appenvironment
              value: {{ .Values.environment}}

Ce fichier forme notre application en type deployement .

Architecture du fichier templates/service.yaml

apiVersion: v1
kind: Service
metadata:
  name: {{ .Release.Name }}-service
  labels:
    app: {{ .Values.label.name }}
spec:
  ports:
  - port: {{ .Values.service.port}}
    protocol: TCP
    targetPort: {{ .Values.container.port }}
  selector:
    app: {{ .Values.label.name }}
  type: {{ .Values.service.type }}

Ce fichier forme notre application pour le mode service.

Déploiement dans AKS via Helm

La commande ci-dessous permet de déployer notre image.

helm install dockerwithlinux ./chart

Déploiement dans AKS sans Helm

Nous allons créer un fichier my1.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dockerwithlinux-app
spec:
  selector:
    matchLabels:
      run: dockerwithlinux
  replicas: 3
  template:
    metadata:
      labels:
        run: dockerwithlinux
    spec:
      containers:
        - name: dockerwithlinux
          image: jlaacr02.azurecr.io/dockerwithlinux:v1
          ports:
            - containerPort: 80
              protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: dockerwithlinux-service
  labels:
    app: dockerwithlinux
spec:
  ports:
  - port: 8888
    protocol: TCP
    targetPort: 80
  selector:
    app: dockerwithlinux
  type: NodePort

Déploiement dans Kubernetes du fichier my1.yaml

kubectl apply -f my1.yaml

Exposition du déploiement en service

kubectl expose deployment dockerwithlinux-deployment --type=LoadBalancer --name=dockerwithlinux-service

Récupération de l’adresse IP externe du service

kubectl get service dockerwithlinux-service

Cette commande nous permet de récupérer notre service ainsi que l’IP externe qui sera tout d’abord dans un état dit « pending » (en attente en français).

getservices.PNG

Nous en avons créé un deuxième de service ici, mais fiez-vous à la commande get-service que vous voyez.

Comme nous pouvons le voir ici, par rapport à ce que nous disions, nos avons un EXTERNAL-IP ou IP externe qui prend tout d’abord un état « en attente » en fonction de l’état de votre cluster (vous n’aurez pas du tout la même IP que nous donc dans l’étape du dessous pensez bien à mettre votre EXTERNAL-IP que la commande vous indiquera).

Test du service

Comme vu juste au dessus, nous allons donc récupérer notre EXTERNAL-IP est l’inclure dans la commande suivante :

curl 20.40.148.135/controllerName/methodName

Mettre capture d’écran.

Nous allons maintenant nous rendre sur le portail Azure, afin de visualiser le cluster WEFACRCluster.

Monitoring

Cluster

portailcluster.PNG

Nous voici à présent sur le portail Azure, dans notre Cluster (pour rappel, pour y accéder il faut aller au niveau de Kubernetes Services, puis sur votre Cluster, et aller dans l’onglet Insights). On peut constater les diverses activités de celui-ci.

On peut voir la quantité de CPU utilisé, la mémoire, le nombre de nœuds ainsi que l’activité des pods.

Contrôleurs

Vous restez sur votre Cluster, et vous devez sélectionner Controller :

controller.PNG

Cette partie contrôleurs, peut s’apparenter au portail Kubernetes qui nous permet de visualiser les différents états de nos images.

 

Conclusion

Comme nous avons pu le voir tout au long de ce tutoriel, Azure est une sorte de baguette magique surpuissante, mais qui dissimule un pouvoir mal compris ou mal utilisé par beaucoup d’entre nous finalement. Hors malgré cela, il ne faut pas simplement le pointer du doigt en disant que c’est le mal, mais plutôt essayer de comprendre en profondeur où cela veut nous mener. Kubernetes et Docker sont de plus en plus mis sur le devant de la scène et pour une meilleure compréhension, nous avons tendance à penser qu’il vaut mieux que vous vous formiez indépendamment d’Azure, car la dissimulation est le pire ennemi du savoir et dans notre milieu, en tant que développeurs, le savoir et la capacité d’apprendre par nous-même est, selon nous, primordial.

 

Article écrit par :

  • Julie LACOGNATA <julie.lacognata@infeeny.com>
  • Kévin ANSARD <kevin.ansard@infeeny.com>

Infeeny est dans le magazine Programmez de Mars 2020

Retrouvez nos experts Infeeny dans le numéro 238 du magazine Programmez de Mars 2020.

On y trouve un article sur le monde du développement selon Microsoft avec un focus sur NET 5, la plateforme unifiée qui va sortir en Novembre 2020. C’est la fusion entre NET Framework 4.8 et NET Core 3.1.

Les experts Infeeny qui ont participé à cet article sont Timothé LARIVIERE et Christophe PICHAUD.