{"id":1562,"date":"2019-09-09T14:44:46","date_gmt":"2019-09-09T14:44:46","guid":{"rendered":"https:\/\/cloudsurfers.it\/2019\/09\/09\/pubblicazione-di-unapplicazione-web-su-azure-kubernetes-service\/"},"modified":"2019-09-09T15:00:32","modified_gmt":"2019-09-09T15:00:32","slug":"pubblicazione-di-unapplicazione-web-su-azure-kubernetes-service","status":"publish","type":"post","link":"https:\/\/cloudsurfers.it\/index.php\/pubblicazione-di-unapplicazione-web-su-azure-kubernetes-service\/","title":{"rendered":"Pubblicazione di un’applicazione web su Azure Kubernetes Service"},"content":{"rendered":"

\"WebApp<\/p>\n

In questa guida verr\u00e0 mostrata la procedura di pubblicazione di un’applicazione Web su Azure<\/strong><\/a> utilizzando il servizio AKS<\/strong><\/a> (Azure Kubernetes Service<\/em>).<\/p>\n

Verr\u00e0 fatta inoltre la distinzione sulla tecnica di pubblicazione nel caso in cui l’applicazione venga sviluppata utilizzando .NET Framework<\/strong>, oppure dotNET Core<\/strong>.<\/p>\n

Le applicazioni Web verranno containerizzate utilizzando Docker<\/a>.<\/strong><\/p>\n

Premessa<\/h2>\n

A seconda della tecnologia utilizzata per lo sviluppo dell’applicazione Web, .NET Framework<\/em> o dotNET Core<\/em>, \u00e8 necessario scegliere un sistema operativo compatibile da utilizzare all’interno del contenitore Docker<\/em>: Windows Server Core<\/strong> per applicazioni .NET Framework<\/em>, oppure Windows Nano Server<\/strong> o Linux<\/strong> per applicazioni dotNET Core<\/em>.<\/p>\n

Di seguito uno schema con le differenze per una scelta adeguata allo scopo.<\/p>\n

\"WebApp<\/p>\n

Caso 1: Applicazione sviluppata in .NET Framework<\/h2>\n

Come anticipato all’interno della premessa, nel caso in cui vogliamo pubblicare un’applicazione sviluppata utilizzando .NET Framework<\/em>, \u00e8 necessario creare un’immagine Docker<\/em> con sistema operativo Windows Server Core<\/strong>.<\/p>\n

Vediamo nello specifico i vari passaggi:<\/p>\n

    \n
  1. Scaricare ed installare Docker Desktop for Windows<\/strong> sulla macchina locale (link<\/a>);<\/li>\n
  2. Una volta installato, impostare il contenitore sulla piattaforma Windows<\/em> dall’icona di Docker<\/em> presente all’interno della barra delle notifiche;<\/li>\n<\/ol>\n

    \"WebApp<\/p>\n

      \n
    1. Aprire il progetto della WebApp<\/em> che si intende pubblicare con Visual Studio<\/em> ed effettuare la compilazione della soluzione;<\/li>\n
    2. Aggiungere il supporto per Docker Compose<\/strong> alla WebApp<\/em> appena compilata: tasto destro del mouse sul progetto della WebApp<\/em>, Aggiungi<\/em>, Supporto per l’agente di orchestrazione del container e selezionare Docker Compose<\/em>;<\/li>\n<\/ol>\n

      \"WebApp<\/p>\n

        \n
      1. All’interno del Dockerfile<\/em> modificare la riga:\n
        \r\nFROM mcr.microsoft.com\/dotnet\/framework\/aspnet:4.7.2-windowsservercore-ltsc2019\r\n<\/pre>\n
        con la seguente riga:<\/p>\n
        \r\nFROM microsoft\/aspnet:4.7.1-windowsservercore-10.0.14393.1884\r\n<\/pre>\n
        Questa operazione \u00e8 necessaria perch\u00e9 gli ACI<\/strong> (Azure Container Instance<\/em>) non supportano una versione di Windows<\/em> superiore alla 10.0.14393 <\/em>nel caso di applicazione .NET Framework;<\/li>\n
      2. Aggiungere quindi un nuovo profilo di pubblicazione: tasto destro del mouse sul progetto della WebApp<\/em>, Pubblica<\/em>, selezionare come target Cartella<\/em>, impostare il percorso di output ed effettuare la pubblicazione della soluzione;<\/li>\n
      3. Editare il file docker-compose.yml<\/strong> modificando il valore del campo image<\/em> con uno a proprio piacimento, per esempio:\n
        \r\nimage: webapp452\r\n<\/pre>\n
        Il nome scelto verr\u00e0 salvato all’interno della variabile $DOCKER_IMAGE<\/strong><\/span>;<\/li>\n
      4. Avviare Windows PowerShell<\/strong> e, una volta posizionati al percorso in cui \u00e8 contenuto il file docker-compose.yml<\/em>, lanciare il seguente comando:\n
        \r\ndocker-compose build\r\n<\/pre>\n<\/li>\n
      5. Accedere al Portale Azure<\/strong> ed aggiungere un nuovo gruppo risorse: Resource Groups<\/em>, Add<\/em> e successivamente impostare un nome (nel nostro caso “RG_Webapp4.5.2”<\/em>). Il nome della risorsa verr\u00e0 salvato nella variabile $RESOURCE_GROUP<\/strong><\/span>;<\/li>\n
      6. Sempre dal Portale Azure<\/em>, aggiungere un nuovo contenitore impostando un nome, il gruppo risorse creato in precedenza, ed abilitando l’utente amministratore.Ad esempio: Container registries<\/em>, Add<\/em> ed impostare come segue:
        \nName:<\/strong> “containerwebapp452<\/em>” ($CONTAINER_NAME<\/em><\/strong><\/span>)
        \nResource Group:<\/strong> $RESOURCE_GROUP<\/strong><\/span>
        \nAdmin User:<\/strong> Enable<\/em><\/li>\n
      7. Restando sul Portale Azure<\/em>, entrare all’interno del contenitore appena creato ed accedere alla sezione Access keys<\/em>. Qui prelevare le informazioni dei campi Username<\/strong> e Password<\/strong>;<\/li>\n
      8. Tornare alla finestra PowerShell<\/em> e digitare il comando:\n
        \r\ndocker login <$CONTAINER_NAME>.azurecr.io -u <$CONTAINER_USERNAME> -p <$CONTAINER_PASSWORD>\r\n<\/pre>\n
        Dove <$CONTAINER_USERNAME><\/strong><\/span> e <<\/strong><\/span>$CONTAINER_PASSWORD><\/strong><\/span> sono i campi prelevati dal Portale Azure<\/em> nel punto precedente;<\/li>\n
      9. Lanciare quindi il comando:\n
        \r\ndocker tag <$DOCKER_IMAGE> <$CONTAINER_NAME>.azurecr.io\/<$DOCKER_IMAGE>\r\n<\/pre>\n
        per applicare il TAG<\/em> all’immagine, e successivamente:<\/p>\n
        \r\ndocker push <$CONTAINER_NAME>.azurecr.io\/<$DOCKER_IMAGE>\r\n<\/pre>\n
        per effettuare il PUSH<\/em> dell’immagine su Docker<\/em>;<\/li>\n
      10. Al termine dell’operazione di PUSH<\/em>, \u00e8 necessario procedere con la creazione di un utente di servizio che avr\u00e0 accesso al cluster AKS<\/em> (Azure Kubernetes Service<\/em>) che andremo a creare successivamente. Lanciare quindi il comando:\n
        \r\naz ad sp create-for-rbac --skip-assignment\r\n<\/pre>\n
        e, dal risultato ottenuto appuntarsi i valori di appId<\/strong> e password<\/strong>;<\/li>\n
      11. A questo punto bisogna assegnare il ruolo di Reader<\/strong> all’utente appena creato per permettergli di effettuare l’operazione di PULL,<\/em> della risorsa oggetto dell’operazione di PUSH<\/em> precedente. In sequenza ecco i due comandi necessari:\n
        \r\naz acr show --resource-group <$RESOURCE_GROUP> --name <$CONTAINER_NAME> --query "id" --output tsv\r\n<\/pre>\n
        Appuntarsi quindi il parametro <$acrId><\/strong> ed utilizzarlo all’interno del seguente comando:<\/p>\n
        \r\naz role assignment create --assignee <$appId> --scope <$acrId> --role Reader\r\n<\/pre>\n<\/li>\n
      12. Ora si pu\u00f2 procedere con la creazione del cluster AKS<\/em> mediante il seguente comando:\n
        \r\naz aks create --resource-group <$RESOURCE_GROUP> --name <$CLUSTER_NAME> --node-count 1 --service-principal <$appId> --client-secret <$password> --generate-ssh-keys --kubernetes-version 1.11.5\r\n<\/pre>\n
        In questo caso verr\u00e0 creato un cluster con singolo nodo. La configurazione rimane comunque editabile anche in un secondo momento e si pu\u00f2 inoltre cambiare il numero di nodi iniziali agendo sul valore del parametro “–node-count<\/em>“.<\/p>\n
        N.B.<\/strong><\/span> Nel caso venga riscontrato l’errore:<\/p>\n
        \r\naz aks create: error: Incorrect padding\r\n<\/pre>\n
        all’interno della PowerShell<\/em>, \u00e8 possibile lanciare il comando di creazione del cluster direttamente dal Portale Azure<\/em> mediante l’uso della Cloud Shell<\/strong>.<\/p>\n
        Se all’interno della Kubernates services<\/strong> del Portale Azure<\/em> appare il cluster appena creato con lo stato “Succeeded<\/em>“, l’operazione \u00e8 terminata con successo ed \u00e8 possibile continuare con la pubblicazione.<\/li>\n
      13. Lanciare il comando:\n
        \r\naz aks install-cli\r\n<\/pre>\n
        e successivamente effettuare la connessione al cluster:<\/p>\n
        \r\naz aks get-credentials --resource-group <$RESOURCE_GROUP> --name <$CLUSTER_NAME>\r\n<\/pre>\n<\/li>\n<\/ol>\n
        Installazione Virtual Kubelet<\/h3>\n
        AKS<\/strong> (Azure Kubernetes Service<\/em>) riesce a gestire in modo automatico dei nodi virtuali verso delle ACI<\/strong> (Azure Container Instance<\/em>) solamente se il contenitore usa un’immagine Linux.<\/em> Per Windows<\/em>\u00a0invece, \u00e8 necessario l’utilizzo di uno strumento chiamato Virtual Kubelet<\/strong>.<\/p>\n
        N.B.<\/strong><\/span> Per installare Virtual Kubelet<\/em> bisogna installare anche Helm<\/strong>.<\/p>\n
        \"WebApp<\/p>\n
          \n
        1. \n
            \n
          1. Creare un file di testo vuoto chiamato rbac-virtual-kubelet.yaml<\/strong> e copiarci il seguente testo:\n
            \r\napiVersion: v1\r\nkind: ServiceAccount\r\nmetadata:\r\n    name: tiller\r\n    namespace: kube-system\r\n---\r\napiVersion: rbac.authorization.k8s.io\/v1\r\nkind: ClusterRoleBinding\r\nmetadata:\r\n    name: tiller\r\nroleRef:\r\n    apiGroup: rbac.authorization.k8s.io\r\n    kind: ClusterRole\r\n    name: cluster-admin\r\nsubjects:\r\n    - kind: ServiceAccount\r\n      name: tiller\r\n      namespace: kube-system\r\n<\/pre>\n<\/li>\n
          2. Posizionarsi all’interno della cartella nel quale \u00e8 stato creato il file e lanciare i seguenti comandi:\n
            \r\nkubectl apply -f rbac-virtual-kubelet.yaml\r\nhelm init --service-account tiller\r\naz aks install-connector --resource-group <$RESOURCE_GROUP> --name <$CLUSTER_NAME> --connector-name virtual-kubelet --os-type Windows\r\n<\/pre>\n
            A questo punto, mediante il comando:<\/p>\n
            \r\nkubectl get nodes\r\n<\/pre>\n
            si dovrebbero vedere due nodi: l’agent<\/strong>, creato al momento della creazione del cluster AKS<\/em>, e il nuovo nodo virtual-kubelet<\/strong> appena creato, da utilizzare come connettore verso i contenitori Windows<\/em>;<\/li>\n
          3. L’utilizzo dei Virtual Kubelet<\/em> rende necessaria la creazione di una chiave segreta<\/u>, questo per poter effettuare il PULL<\/em> dell’immagine. Tramite PowerShell<\/em>, usare quindi la seguente sequenza di comandi, sostituendo le variabili con i valori assegnati precedentemente:\n
            \r\n$ACR_NAME="<$CONTAINER_NAME>"\r\n$SERVICE_PRINCIPAL_NAME="<$CONTAINER_USERNAME>"\r\n$ACR_LOGIN_SERVER=$(az acr show --name $ACR_NAME --query loginServer --output tsv)\r\n$ACR_REGISTRY_ID=$(az acr show --name $ACR_NAME --query id --output tsv)\r\n$SP_PASSWD=$(az ad sp create-for-rbac --name $SERVICE_PRINCIPAL_NAME --role acrpull --scopes $ACR_REGISTRY_ID --query password --output tsv)\r\n$CLIENT_ID=$(az ad sp show --id http:\/\/$SERVICE_PRINCIPAL_NAME --query appId --output tsv)\r\nkubectl create secret docker-registry acr-auth --docker-server $ACR_LOGIN_SERVER --docker-username $SERVICE_PRINCIPAL_NAME --docker-password <$CONTAINER_PASSWORD> --docker-email <$ACCOUNT_EMAIL>\r\n<\/pre>\n<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n
            Pubblicazione dell’immagine<\/h3>\n
            A questo punto siamo pronti per la pubblicazione, sul cluster, dell’immagine caricata all’interno del contenitore ACI<\/em> (Azure Container Instance<\/em>).<\/p>\n
              \n
            1. Per procedere, va creato un file di testo vuoto chiamato, ad esempio, virtual-kubelet-windows.yaml<\/strong> contenente:\n
              \r\napiVersion: apps\/v1\r\nkind: Deployment\r\nmetadata:\r\n    name: <$DOCKER_IMAGE>\r\nspec:\r\n    replicas: <$PODS_NUMBER>\r\n    selector:\r\n        matchLabels:\r\n            app: <$DOCKER_IMAGE>\r\n    template:\r\n        metadata:\r\n            labels:\r\n                app: <$DOCKER_IMAGE>\r\n        spec:\r\n            containers:\r\n            - name: <$DOCKER_IMAGE>\r\n              image: <$CONTAINER_NAME>.azurecr.io\/<$DOCKER_IMAGE>\r\n              ports:\r\n              - containerPort: 80\r\n              imagePullPolicy: Always\r\n            imagePullSecrets:\r\n            - name: acr-auth\r\n            nodeSelector:\r\n                beta.kubernetes.io\/os: windows\r\n                kubernetes.io\/role: agent\r\n                type: virtual-kubelet\r\n            tolerations:\r\n            - key: virtual-kubelet.io\/provider\r\n              operator: Equal\r\n              value: azure\r\n              effect: NoSchedule\r\n---\r\napiVersion: v1\r\nkind: Service\r\nmetadata:\r\n    name: <$DOCKER_IMAGE>\r\nspec:\r\n    type: LoadBalancer\r\n    ports:\r\n    - port: 80\r\n    selector:\r\n        app: <$DOCKER_IMAGE>\r\n<\/pre>\n
              Le variabili: <$DOCKER_IMAGE><\/strong><\/span>, <$PODS_NUMBER><\/strong><\/span> e <$CONTAINER_NAME><\/strong><\/span> vanno sostituite con i parametri di configurazione assegnati precedentemente;<\/li>\n
            2. Tramite PowerShell<\/em>, posizionarsi all’interno del percorso che contiene il file appena creato e lanciare il seguente comando:\n
              \r\nkubectl apply -f virtual-kubelet-windows.yaml\r\n<\/pre>\n
              Cos\u00ec facendo, verranno originati diversi POD<\/em>, ognuno dei quali punter\u00e0 ad una ACI<\/em>, e saranno tutti gestiti dal Virtual Kubelet<\/em> creato in precedenza.<\/p>\n
              Il completamento dell’operazione dura in genere alcuni minuti, anche in base al numero di POD<\/em> che deve generare.<\/p>\n
              Per monitorarne lo stato di creazione \u00e8 possibile accedere alla sezione Container Instances<\/strong> del Portale Azure<\/em>. Lo stato “Creating<\/em>” indica che l’operazione \u00e8 ancora in corso.<\/li>\n<\/ol>\n
              Dal Portale Azure<\/em> \u00e8 anche possibile conoscere l’IP<\/em> pubblico con cui accedere al set di POD<\/em> appena creato. Per farlo:<\/p>\n
                \n
              1. Cliccare su uno dei POD<\/em> appena creato;<\/li>\n
              2. Tramite il link Resource Group<\/em> si apriranno gli elementi associati al gruppo di risorse, selezionare quello con il parametro Type<\/em> assegnato come Load Balancer<\/em>;<\/li>\n
              3. Tra le molteplici informazioni mostrate, vi \u00e8 anche Public IP address<\/em>, l’indirizzo pubblico con cui accedere al cluster creato.<\/li>\n<\/ol>\n
                Caso 2: Applicazione sviluppata in .NET Core<\/h2>\n
                Nel caso avessimo a che fare con un applicazione sviluppata con tecnologia .NET Core<\/strong>, all’interno del contenitore Docker<\/em> \u00e8 possibile utilizzare sia il sistema operativo Windows Nano Server<\/strong>, oppure Linux<\/strong>.<\/p>\n
                Vediamo anche per questo caso i vari passaggi:<\/p>\n
                  \n
                1. \u00a0Seguire i passaggi 1<\/em> e 2<\/em> descritti nel Caso 1<\/strong>, per scaricare ed installare Docker Desktop for Windows<\/strong>;<\/li>\n
                2. Aprire il progetto WebApp<\/em> su Visual Studio<\/em> ed aggiungere un file di nome Dockerfile<\/strong> all’interno della root;<\/li>\n
                3. All’interno del Dockerfile<\/strong> aggiungere il seguente testo:\n
                  \r\nFROM microsoft\/dotnet:2.2-aspnetcore-runtime\r\nARG source=.\r\nWORKDIR \/app\r\nEXPOSE 80\r\nCOPY $source .\r\nENTRYPOINT ["dotnet", "<$DLL_STARTUP_PROJECT>"]\r\n<\/pre>\n
                  Dove il parametro <$DLL_STARTUP_PROJECT><\/strong><\/span> dovr\u00e0 essere sostituito con il nome della dll<\/strong><\/em> del progetto di partenza.<\/p>\n
                  Inoltre il Dockerfile<\/em> deve sempre essere copiato all’interno della directory di output (“Copy Always<\/strong>” nelle propriet\u00e0 del file<\/em>);<\/li>\n
                4. Creare un profilo di pubblicazione della WebApp<\/em>, impostare l’output su FileSystem<\/em> e chiamarlo DockerProfile<\/strong>.
                  \nCome impostazioni di pubblicazione usare le seguenti:
                  \nConfigurazione:<\/strong> Release<\/em>
                  \nModalit\u00e0 destinazione:<\/strong> Dipendente del framework<\/em>
                  \nRuntime:<\/strong> Linux-64<\/em>
                  \nOpzioni pubblicazione:<\/strong> Elimina tutti i file esistenti<\/em><\/li>\n
                5. Avviare quindi la pubblicazione ed attendere l’esito;<\/li>\n
                6. Aprire PowerShell<\/em> e creare l’immagine Docker<\/em> tramite il seguente comando:\n
                  \r\ndocker build <$PUBLISH_FOLDER> -t <$CONTAINER_NAME>.azurecr.io\/<$DOCKER_IMAGE>:0\r\n<\/pre>\n<\/li>\n
                7. Al termine della creazione dell’immagine, effettuarne il PUSH<\/em> verso ACI<\/em> (Azure Container Instance<\/em>) con il comando:\n
                  \r\ndocker push <$CONTAINER_NAME>.azurecr.io\/<$DOCKER_IMAGE>:0\r\n<\/pre>\n<\/li>\n
                8. Seguire dal punto 14<\/em> al 17<\/em> mostrati all’interno del Caso 1<\/strong>;<\/li>\n
                9. A questo punto l’immagine caricata sul contenitore ACI<\/em> \u00e8 pronta per la pubblicazione.Creare quindi un nuovo file chiamato webapp.yaml<\/strong> e copiarci al suo interno il seguente testo:\n
                  \r\napiVersion: apps\/v1\r\nkind: Deployment\r\nmetadata:\r\n    name: <$DOCKER_IMAGE>\r\nspec:\r\n    replicas: <$PODS_NUMBER>\r\n    selector:\r\n        matchLabels:\r\n            app: <$DOCKER_IMAGE>\r\n    template:\r\n        metadata:\r\n            labels:\r\n                app: <$DOCKER_IMAGE>\r\n        spec:\r\n            containers:\r\n            - name: <$DOCKER_IMAGE>\r\n              image: <$CONTAINER_NAME>.azurecr.io\/<$DOCKER_IMAGE>\r\n              ports:\r\n              - containerPort: 80\r\n              imagePullPolicy: Always\r\n            imagePullSecrets:\r\n            - name: acr-auth\r\n---\r\napiVersion: v1\r\nkind: Service\r\nmetadata:\r\n    name: <$DOCKER_IMAGE>\r\nspec:\r\n    type: LoadBalancer\r\n    ports:\r\n    - port: 80\r\n    selector:\r\n        app: <$DOCKER_IMAGE>\r\n<\/pre>\n
                  Sostituire le variabili: <$DOCKER_IMAGE><\/strong><\/span>, <$PODS_NUMBER><\/strong><\/span> e <$CONTAINER_NAME><\/strong><\/span> con i parametri opportuni di configurazione;<\/li>\n
                10. Tramite PowerShell<\/em> posizionarsi al percorso nel quale \u00e8 stato creato il file webapp.yaml<\/strong> e lanciare il seguente comando per procedere con la pubblicazione finale:\n
                  \r\nkubectl apply -f webapp.yaml\r\n<\/pre>\n<\/li>\n<\/ol>\n","protected":false},"excerpt":{"rendered":"
                  In questa guida verr\u00e0 mostrata la procedura di pubblicazione di un’applicazione Web su Azure utilizzando il servizio AKS (Azure Kubernetes Service). Verr\u00e0 fatta inoltre la distinzione sulla tecnica di pubblicazione …<\/p>\n","protected":false},"author":3,"featured_media":1563,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"wds_primary_category":0,"footnotes":""},"categories":[76,71],"tags":[80,83,82],"class_list":["post-1562","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-azure-en","category-guides","tag-application","tag-docker-en","tag-k8s-en"],"_links":{"self":[{"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/posts\/1562","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/comments?post=1562"}],"version-history":[{"count":0,"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/posts\/1562\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/media\/1563"}],"wp:attachment":[{"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/media?parent=1562"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/categories?post=1562"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/cloudsurfers.it\/index.php\/wp-json\/wp\/v2\/tags?post=1562"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}