Usare Draft con il servizio contenitore di Azure e il Registro contenitori di Azure per compilare e distribuire un'applicazione in KubernetesUse Draft with Azure Container Service and Azure Container Registry to build and deploy an application to Kubernetes

Avviso

Si sta visualizzando la documentazione per la versione precedente del servizio contenitore di Azure.You are viewing documentation for the old version of the Azure Container Service. Il servizio contenitore di Azure è in fase di aggiornamento con l'aggiunta di nuove opzioni di distribuzione, funzionalità di gestione migliorate e vantaggi economici in Kubernetes in Azure.Azure Container Service (AKS) is being updated to add new deployment options, enhanced management capabilities, and cost benefit to Kubernetes on Azure. Per iniziare a usare tali funzionalità in anteprima, vedere AKS documentation (Documentazione del servizio contenitore di Azure).Visit the AKS documentation to start working with these preview features.

Draft è un nuovo strumento open source che semplifica lo sviluppo di applicazioni basate su contenitori e la loro distribuzione in cluster Kubernetes senza necessità di conoscere a fondo Docker e Kubernetes, né di installarli.Draft is a new open-source tool that makes it easy to develop container-based applications and deploy them to Kubernetes clusters without knowing much about Docker and Kubernetes -- or even installing them. Con strumenti come Draft, gli sviluppatori e i loro team possono concentrarsi sulla compilazione dell'applicazione con Kubernetes, senza fare molta attenzione all'infrastruttura.Using tools like Draft let you and your teams focus on building the application with Kubernetes, not paying as much attention to infrastructure.

È possibile usare Draft con qualsiasi registro di immagini Docker e cluster Kubernetes, anche in locale.You can use Draft with any Docker image registry and any Kubernetes cluster, including locally. Questa esercitazione illustra come usare il servizio contenitore di Azure con Kubernetes e Registro contenitori di Azure per creare una pipeline di sviluppo attiva ma protetta in Kubernetes usando Draft e come usare il servizio DNS di Azure per consentire la visualizzazione di tale pipeline di sviluppo agli altri utenti in un dominio.This tutorial shows how to use ACS with Kubernetes and ACR to create a live but secure developer pipeline in Kubernetes using Draft, and how to use Azure DNS to expose that developer pipeline for others to see at a domain.

Creare un Registro contenitori di AzureCreate an Azure Container Registry

È possibile creare un nuovo Registro contenitori di Azure facilmente, ma i passaggi sono i seguenti:You can easily create a new Azure Container Registry, but the steps are as follows:

  1. Creare un gruppo di risorse di Azure per gestire il Registro contenitori di Azure e il cluster Kubernetes nel servizio contenitore di Azure.Create a Azure resource group to manage your ACR registry and the Kubernetes cluster in ACS.

    az group create --name draft --location eastus
    
  2. Creare un registro di immagini del Registro contenitori di Azure usando az acr create e verificare che l'opzione --admin-enabled sia impostata su true.Create an ACR image registry using az acr create and ensure that the --admin-enabled option is set to true.

    az acr create --resource-group draft --name draftacs --sku Basic
    

Creare un servizio contenitore di Azure con KubernetesCreate an Azure Container Service with Kubernetes

A questo punto, è possibile usare az acs create per creare un cluster ACS usando Kubernetes come valore --orchestrator-type.Now you're ready to use az acs create to create an ACS cluster using Kubernetes as the --orchestrator-type value.

az acs create --resource-group draft --name draft-kube-acs --dns-prefix draft-cluster --orchestrator-type kubernetes --generate-ssh-keys

Nota

Poiché Kubernetes non è il tipo di agente di orchestrazione predefinito, assicurarsi di usare l'opzione --orchestrator-type kubernetes.Because Kubernetes is not the default orchestrator type, be sure you use the --orchestrator-type kubernetes switch.

L'output, in caso di esito positivo, è simile al seguente.The output when successful looks similar to the following.

waiting for AAD role to propagate.done
{
  "id": "/subscriptions/<guid>/resourceGroups/draft/providers/Microsoft.Resources/deployments/azurecli14904.93snip09",
  "name": "azurecli1496227204.9323909",
  "properties": {
    "correlationId": "<guid>",
    "debugSetting": null,
    "dependencies": [],
    "mode": "Incremental",
    "outputs": null,
    "parameters": {
      "clientSecret": {
        "type": "SecureString"
      }
    },
    "parametersLink": null,
    "providers": [
      {
        "id": null,
        "namespace": "Microsoft.ContainerService",
        "registrationState": null,
        "resourceTypes": [
          {
            "aliases": null,
            "apiVersions": null,
            "locations": [
              "westus"
            ],
            "properties": null,
            "resourceType": "containerServices"
          }
        ]
      }
    ],
    "provisioningState": "Succeeded",
    "template": null,
    "templateLink": null,
    "timestamp": "2017-05-31T10:46:29.434095+00:00"
  },
  "resourceGroup": "draft"
}

Dopo aver creato un cluster, è possibile importare le credenziali usando il comando az acs kubernetes get-credentials.Now that you have a cluster, you can import the credentials by using the az acs kubernetes get-credentials command. A questo punto, si ha un file di configurazione locale per il cluster, necessario per Helm e Draft.Now you have a local configuration file for your cluster, which is what Helm and Draft need to get their work done.

Installare e configurare DraftInstall and configure draft

  1. Scaricare Draft per il proprio ambiente all'indirizzo https://github.com/Azure/draft/releases e installarlo in PATH in modo da poter usare il comando.Download draft for your environment at https://github.com/Azure/draft/releases and install into your PATH so that the command can be used.
  2. Scaricare Helm per il proprio ambiente all'indirizzo https://github.com/kubernetes/helm/releases e installarlo in PATH in modo da poter usare il comando.Download helm for your environment at https://github.com/kubernetes/helm/releases and install it into your PATH so that the command can be used.
  3. Configurare Draft per usare il registro e creare sottodomini per ogni grafico Helm creato.Configure Draft to use your registry and create subdomains for each Helm chart it creates. Per configurare Draft sono necessari:To configure Draft, you need:

    • Il nome del Registro contenitori di Azure (in questo esempio, draftacsdemo)your Azure Container Registry name (in this example, draftacsdemo)
    • La chiave, o password, del registro da az acr credential show -n <registry name> --output tsv --query "passwords[0].value".your registry key, or password, from az acr credential show -n <registry name> --output tsv --query "passwords[0].value".

    Chiamare draft init. Il processo di configurazione richiede i valori sopra indicati. Si noti che il formato dell'URL per l'URL del registro è il nome del registro (in questo esempio, draftacsdemo) più .azurecr.io.Call draft init and the configuration process prompts you for the values above; note that the URL format for the registry URL is the registry name (in this example, draftacsdemo) plus .azurecr.io. Il nome utente è il nome del registro da solo.Your username is the registry name on its own. Alla prima esecuzione, il processo è simile al seguente.The process looks something like the following the first time you run it.

     $ draft init
     Creating /home/ralph/.draft 
     Creating /home/ralph/.draft/plugins 
     Creating /home/ralph/.draft/packs 
     Creating pack go...
     Creating pack python...
     Creating pack ruby...
     Creating pack javascript...
     Creating pack gradle...
     Creating pack java...
     Creating pack php...
     Creating pack csharp...
     $DRAFT_HOME has been configured at /home/ralph/.draft.
    
     In order to configure Draft, we need a bit more information...
    
     1. Enter your Docker registry URL (e.g. docker.io/myuser, quay.io/myuser, myregistry.azurecr.io): draftacsdemo.azurecr.io
     2. Enter your username: draftacsdemo
     3. Enter your password: 
     Draft has been installed into your Kubernetes Cluster.
     Happy Sailing!
    

A questo punto, è possibile distribuire un'applicazione.Now you're ready to deploy an application.

Compilare e distribuire un'applicazioneBuild and deploy an application

Nel repository di Draft ci sono sei semplici applicazioni di esempio.In the Draft repo are six simple example applications. Clonare il repository e usare l'esempio Java.Clone the repo and let's use the Java example. Passare alla directory examples/java e digitare draft create per compilare l'applicazione.Change into the examples/java directory, and type draft create to build the application. Il risultato dovrebbe essere simile al seguente.It should look like the following example.

$ draft create
--> Draft detected the primary language as Java with 91.228814% certainty.
--> Ready to sail

L'output include un Dockerfile e un grafico Helm.The output includes a Dockerfile and a Helm chart. Per la compilazione e la distribuzione è sufficiente digitare draft up.To build and deploy, you just type draft up. L'output è esteso, ma dovrebbe essere simile all'esempio seguente.The output is extensive, but should be like the following example.

$ draft up
Draft Up Started: 'handy-labradoodle'
handy-labradoodle: Building Docker Image: SUCCESS ⚓  (35.0232s)
handy-labradoodle: Pushing Docker Image: SUCCESS ⚓  (17.0062s)
handy-labradoodle: Releasing Application: SUCCESS ⚓  (3.8903s)
handy-labradoodle: Build ID: 01BT0ZJ87NWCD7BBPK4Y3BTTPB

Visualizzare in modo sicuro l'applicazioneSecurely view your application

Il contenitore viene ora eseguito in servizio contenitore di Azure.Your container is now running in ACS. Per visualizzarlo, usare il comando draft connect che crea una connessione protetta all'indirizzo IP del cluster con una porta specifica per l'applicazione in modo da consentire la visualizzazione in locale.To view it, use the draft connect command, which creates a secured connection to the cluster's IP with a specific port for your application so that you can view it locally. Se ha esito positivo, cercare l'URL per la connessione all'app nella prima riga dopo l'indicatore SUCCESS.If successful, look for the URL to connect to your app on the first line after the SUCCESS indicator.

Nota

Se si riceve un messaggio che informa che nessun pod è pronto, attendere e riprovare oppure controllare quando i pod sono pronti con kubectl get pods -w e quindi riprovare.If you receive a message saying that no pods were ready, wait for a moment and retry, or you can watch the pods become ready with kubectl get pods -w and then retry when they do.

draft connect
Connecting to your app...SUCCESS...Connect to your app on localhost:46143
Starting log streaming...
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
== Spark has ignited ...
>> Listening on 0.0.0.0:4567

Nell'esempio precedente è possibile digitare curl -s http://localhost:46143 per ricevere la risposta, Hello World, I'm Java!.In the preceding example, you could type curl -s http://localhost:46143 to receive the reply, Hello World, I'm Java!. Premendo CTRL+ o CMD+C (a seconda del sistema operativo), il tunnel sicuro viene eliminato ed è possibile continuare a eseguire iterazioni.When you CTRL+ or CMD+C (depending on your OS environment), the secure tunnel is torn down and you can continue iterating.

Condivisione dell'applicazione tramite la configurazione di un dominio di distribuzione con DNS di AzureSharing your application by configuring a deployment domain with Azure DNS

È già stato eseguito il ciclo di iterazione di sviluppo creato da Draft nei passaggi precedenti.You have already performed the developer iteration loop that Draft creates in the preceding steps. Tuttavia, è possibile condividere l'applicazione su Internet eseguendo queste operazioni:However, you can share your application across the internet by:

  1. Installazione di un ingresso nel cluster del servizio contenitore di Azure (per fornire un indirizzo IP pubblico per visualizzare l'app)Installing an ingress in your ACS cluster (to provide a public IP address at which to display the app)
  2. Delega del dominio personalizzato a DNS di Azure e mapping del dominio all'indirizzo IP assegnato dal servizio contenitore di Azure al controller di ingressoDelegating your custom domain to Azure DNS and mapping your domain to the IP address ACS assigns to your ingress controller

Usare Helm per installare il controller di ingresso.Use helm to install the ingress controller.

Usare Helm per cercare e installare stable/traefik e il controller di ingresso per abilitare le richieste in ingresso per le compilazioni.Use helm to search for and install stable/traefik, an ingress controller, to enable inbound requests for your builds.

$ helm search traefik
NAME            VERSION DESCRIPTION
stable/traefik  1.3.0   A Traefik based Kubernetes ingress controller w...

$ helm install stable/traefik --name ingress

Impostare quindi un'espressione di controllo sul controller ingress per acquisire il valore IP esterno quando viene distribuito.Now set a watch on the ingress controller to capture the external IP value when it is deployed. Questo indirizzo IP sarà quello mappato al dominio di distribuzione nella sezione successiva.This IP address will be the one mapped to your deployment domain in the next section.

$ kubectl get svc -w
NAME                          CLUSTER-IP     EXTERNAL-IP     PORT(S)                      AGE
ingress-traefik               10.0.248.104   13.64.108.240   80:31046/TCP,443:32556/TCP   1h
kubernetes                    10.0.0.1       <none>          443/TCP                      7h

In questo caso, l'IP esterno per il dominio di distribuzione è 13.64.108.240.In this case, the external IP for the deployment domain is 13.64.108.240. È ora possibile mappare il dominio a tale IP.Now you can map your domain to that IP.

Mappare l'indirizzo IP dell'ingresso a un sottodominio personalizzatoMap the ingress IP to a custom subdomain

Draft crea una versione per ogni grafico Helm creato, ovvero ogni applicazione a cui si sta lavorando.Draft creates a release for each Helm chart it creates -- each application you are working on. Ogni versione ottiene un nome generato, usato da Draft come sottodominio del dominio di distribuzione radice controllato dall'utente.Each one gets a generated name that is used by draft as a subdomain on top of the root deployment domain that you control. In questo esempio viene usato squillace.io come dominio di distribuzione. Per abilitare questo comportamento del sottodominio, è necessario creare un record A per '*.draft' nelle voci DNS per il dominio di distribuzione, in modo che venga eseguito il routing di ogni sottodominio generato al controller di ingresso del cluster Kubernetes.(In this example, we use squillace.io as the deployment domain.) To enable this subdomain behavior, you must create an A record for '*.draft' in your DNS entries for your deployment domain, so that each generated subdomain is routed to the Kubernetes cluster's ingress controller.

Ogni provider di dominio assegna i server DNS in un modo specifico. Per delegare i server dei nomi di dominio al servizio DNS di Azure, seguire questa procedura:Your own domain provider has their own way to assign DNS servers; to delegate your domain nameservers to Azure DNS, you take the following steps:

  1. Creare un gruppo di risorse per la propria zona.Create a resource group for your zone.

    az group create --name squillace.io --location eastus
    {
      "id": "/subscriptions/<guid>/resourceGroups/squillace.io",
      "location": "eastus",
      "managedBy": null,
      "name": "zones",
      "properties": {
        "provisioningState": "Succeeded"
      },
      "tags": null
    }
    
  2. Creare una zona DNS per il proprio dominio.Create a DNS zone for your domain. Usare il comando az network dns zone create per ottenere i server dei nomi per delegare il controllo DNS al servizio DNS di Azure per il dominio.Use the az network dns zone create command to obtain the nameservers to delegate DNS control to Azure DNS for your domain.

    az network dns zone create --resource-group squillace.io --name squillace.io
    {
      "etag": "<guid>",
      "id": "/subscriptions/<guid>/resourceGroups/zones/providers/Microsoft.Network/dnszones/squillace.io",
      "location": "global",
      "maxNumberOfRecordSets": 5000,
      "name": "squillace.io",
      "nameServers": [
        "ns1-09.azure-dns.com.",
        "ns2-09.azure-dns.net.",
        "ns3-09.azure-dns.org.",
        "ns4-09.azure-dns.info."
      ],
      "numberOfRecordSets": 2,
      "resourceGroup": "squillace.io",
      "tags": {},
      "type": "Microsoft.Network/dnszones"
    }
    
  3. Aggiungere i server DNS ottenuti al provider di dominio per il dominio di distribuzione, per poter usare il servizio DNS di Azure per modificare il puntamento del dominio come desiderato.Add the DNS servers you are given to the domain provider for your deployment domain, which enables you to use Azure DNS to repoint your domain as you want. Il modo in cui si esegue questa operazione varia in base al dominio specificato. L'articolo Delegare un dominio al servizio DNS di Azure contiene alcune informazioni che è necessario conoscere.The way you do this varies by domain provide; delegate your domain nameservers to Azure DNS contains some of the details that you should know.
  4. Dopo aver delegato il dominio al servizio DNS di Azure, creare una voce di recordset A per il mapping del dominio di distribuzione all'indirizzo IP ingress del passaggio 2 della sezione precedente.Once your domain has been delegated to Azure DNS, create an A record-set entry for your deployment domain mapping to the ingress IP from step 2 of the previous section. azurecli az network dns record-set a add-record --ipv4-address 13.64.108.240 --record-set-name '*.draft' -g squillace.io -z squillace.io L'output è simile al seguente:The output looks something like: json { "arecords": [ { "ipv4Address": "13.64.108.240" } ], "etag": "<guid>", "id": "/subscriptions/<guid>/resourceGroups/squillace.io/providers/Microsoft.Network/dnszones/squillace.io/A/*", "metadata": null, "name": "*.draft", "resourceGroup": "squillace.io", "ttl": 3600, "type": "Microsoft.Network/dnszones/A" }
  5. Reinstallare DraftReinstall draft

    1. Rimuovere draftd dal cluster digitando helm delete --purge draft.Remove draftd from the cluster by typing helm delete --purge draft.
    2. Reinstallare Draft usando lo stesso comando draft-init, ma con l'opzione --ingress-enabled:Reinstall draft by using the same draft-init command, but with the --ingress-enabled option: bash draft init --ingress-enabled Rispondere alle richieste, come la prima volta.Respond to the prompts as you did the first time, above. Occorre tuttavia rispondere a un'altra domanda usando il percorso completo del dominio configurato con DNS di Azure.However, you have one more question to respond to, using the complete domain path that you configured with the Azure DNS.
  6. Immettere il dominio di primo livello per il traffico in ingresso (ad esempio draft.example.com): draft.squillace.ioEnter your top-level domain for ingress (e.g. draft.example.com): draft.squillace.io

  7. Quando si chiama draft up questa volta, sarà possibile visualizzare l'applicazione (o curl) nell'URL nel formato <appname>.draft.<domain>.<top-level-domain>.When you call draft up this time, you will be able to see your application (or curl it) at the URL of the form <appname>.draft.<domain>.<top-level-domain>. Nel caso descritto in questo esempio, http://handy-labradoodle.draft.squillace.io.In the case of this example, http://handy-labradoodle.draft.squillace.io. bash curl -s http://handy-labradoodle.draft.squillace.io Hello World, I'm Java!

Passaggi successiviNext steps

Ora che è stato creato un cluster Kubernetes ACS, è possibile provare a usare il Registro contenitori di Azure per creare altre distribuzioni diverse di questo scenario.Now that you have an ACS Kubernetes cluster, you can investigate using Azure Container Registry to create more and different deployments of this scenario. È ad esempio possibile creare un recordset DNS di dominio draft.basedomain.toplevel che controlla le attività all'esterno di un sottodominio più profondo per distribuzioni specifiche del servizio contenitore di Azure.For example, you can create a draft.basedomain.toplevel domain DNS record-set that controls things off of a deeper subdomain for specific ACS deployments.