One place for hosting & domains

      Como compilar um aplicativo Node.js com o Docker [Início rápido]


      Introdução

      Este tutorial traz um passo a passo para ajudá-lo na criação de uma imagem de aplicativo para um website estático que utilize o framework Express e o Bootstrap. Em seguida, você irá compilar um contêiner usando essa imagem, irá enviá-la para o Docker Hub e a utilizará para compilar outro contêiner, demonstrando como é possível recriar e dimensionar o seu aplicativo.

      Para obter uma versão mais detalhada deste tutorial, com explicações mais detalhadas de cada passo, consulte o tutorial Como compilar um aplicativo Node.js com o Docker.

      Pré-requisitos

      Para seguir este tutorial, você vai precisar do seguinte:

      • Um usuário sudo em seu servidor ou em seu ambiente local.
      • O Docker.
      • Node.js e npm.
      • Uma conta do Docker Hub.

      Passo 1 — Instalando as dependências do seu aplicativo

      Primeiro, crie um diretório para seu projeto em seu diretório home do usuário não raiz:

      Navegue até este diretório:

      Esse será o diretório raiz do projeto.

      Em seguida, crie um package.json com as dependências do seu projeto:

      Adicione as seguintes informações sobre o projeto ao arquivo; certifique-se de substituir as informações do autor pelo seu nome e detalhes de contato:

      ~/node_project/package.json

      {
        "name": "nodejs-image-demo",
        "version": "1.0.0",
        "description": "nodejs image demo",
        "author": "Sammy the Shark <sammy@example.com>",
        "license": "MIT",
        "main": "app.js",
        "scripts": {
          "start": "node app.js",
          "test": "echo "Error: no test specified" && exit 1"
        },
        "keywords": [
          "nodejs",
          "bootstrap",
          "express"
        ],
        "dependencies": {
          "express": "^4.16.4"
        }
      }
      

      Instale as dependências do seu projeto:

      Passo 2 — Criando os arquivos do aplicativo

      Criaremos um site que fornece informações aos usuários sobre tubarões.

      Abra o app.js no diretório principal do projeto para definir as rotas do projeto:

      Adicione o conteúdo a seguir ao arquivo para criar o aplicativo Express e os objetos Router, definir o diretório base, a porta e o host como variáveis, definir as rotas e, em seguida, montar o middleware router junto com os ativos estáticos do aplicativo:

      ~/node_project/app.js

      var express = require("express");
      var app = express();
      var router = express.Router();
      
      var path = __dirname + '/views/';
      
      // Constants
      const PORT = 8080;
      const HOST = '0.0.0.0';
      
      router.use(function (req,res,next) {
        console.log("/" + req.method);
        next();
      });
      
      router.get("/",function(req,res){
        res.sendFile(path + "index.html");
      });
      
      router.get("/sharks",function(req,res){
        res.sendFile(path + "sharks.html");
      });
      
      app.use(express.static(path));
      app.use("/", router);
      
      app.listen(8080, function () {
        console.log('Example app listening on port 8080!')
      })
      

      Em seguida, vamos adicionar conteúdo estático ao aplicativo. Crie o diretório views:

      Abra o index.html:

      Adicione o código a seguir ao arquivo, que importará o Boostrap e criará um componente jumbotron com um link para a página de informações mais detalhadas do sharks.html:

      ~/node_project/views/index.html

      <!DOCTYPE html>
      <html lang="en">
         <head>
            <title>About Sharks</title>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
            <link href="css/styles.css" rel="stylesheet">
            <link href='https://fonts.googleapis.com/css?family=Merriweather:400,700' rel='stylesheet' type='text/css'>
            <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
            <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
         </head>
         <body>
            <nav class="navbar navbar-inverse navbar-static-top">
               <div class="container">
                  <div class="navbar-header">
                     <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                     <span class="sr-only">Toggle navigation</span>
                     <span class="icon-bar"></span>
                     <span class="icon-bar"></span>
                     <span class="icon-bar"></span>
                     </button>
                     <a class="navbar-brand" href="https://www.digitalocean.com/#">Everything Sharks</a>
                  </div>
                  <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
                     <ul class="nav navbar-nav mr-auto">
                        <li class="active"><a href="/">Home</a></li>
                        <li><a href="http://www.digitalocean.com/sharks">Sharks</a></li>
                     </ul>
                  </div>
               </div>
            </nav>
            <div class="jumbotron">
               <div class="container">
                  <h1>Want to Learn About Sharks?</h1>
                  <p>Are you ready to learn about sharks?</p>
                  <br>
                  <p><a class="btn btn-primary btn-lg" href="http://www.digitalocean.com/sharks" role="button">Get Shark Info</a></p>
               </div>
            </div>
            <div class="container">
               <div class="row">
                  <div class="col-md-6">
                     <h3>Not all sharks are alike</h3>
                     <p>Though some are dangerous, sharks generally do not attack humans. Out of the 500 species known to researchers, only 30 have been known to attack humans.</p>
                  </div>
                  <div class="col-md-6">
                     <h3>Sharks are ancient</h3>
                     <p>There is evidence to suggest that sharks lived up to 400 million years ago.</p>
                  </div>
               </div>
            </div>
         </body>
      </html>
      

      Em seguida, abra um arquivo chamado sharks.html:

      Adicione o código a seguir, o qual importará o Bootstrap e a folha de estilos personalizada e fornecerá informações detalhadas sobre certos tubarões:

      ~/node_project/views/sharks.html

      <!DOCTYPE html>
      <html lang="en">
         <head>
            <title>About Sharks</title>
            <meta charset="utf-8">
            <meta name="viewport" content="width=device-width, initial-scale=1">
            <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
            <link href="css/styles.css" rel="stylesheet">
            <link href='https://fonts.googleapis.com/css?family=Merriweather:400,700' rel='stylesheet' type='text/css'>
            <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
            <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
         </head>
         <nav class="navbar navbar-inverse navbar-static-top">
            <div class="container">
               <div class="navbar-header">
                  <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                  <span class="sr-only">Toggle navigation</span>
                  <span class="icon-bar"></span>
                  <span class="icon-bar"></span>
                  <span class="icon-bar"></span>
                  </button>
                  <a class="navbar-brand" href="https://www.digitalocean.com/#">Everything Sharks</a>
               </div>
               <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
                  <ul class="nav navbar-nav mr-auto">
                     <li><a href="/">Home</a></li>
                     <li class="active"><a href="http://www.digitalocean.com/sharks">Sharks</a></li>
                  </ul>
               </div>
            </div>
         </nav>
         <div class="jumbotron text-center">
            <h1>Shark Info</h1>
         </div>
         <div class="container">
            <div class="row">
               <div class="col-md-6">
                  <p>
                  <div class="caption">Some sharks are known to be dangerous to humans, though many more are not. The sawshark, for example, is not considered a threat to humans.</div>
                  <img src="https://assets.digitalocean.com/articles/docker_node_image/sawshark.jpg" alt="Sawshark">
                  </p>
               </div>
               <div class="col-md-6">
                  <p>
                  <div class="caption">Other sharks are known to be friendly and welcoming!</div>
                  <img src="https://assets.digitalocean.com/articles/docker_node_image/sammy.png" alt="Sammy the Shark">
                  </p>
               </div>
            </div>
          </div>
         </body>
      </html>
      

      Por fim, crie a folha de estilos CSS personalizada que você vinculou ao index.html e ao sharks.html, criando primeiro uma pasta css no diretório views:

      Abra a folha de estilos e adicione o código a seguir, o qual definirá a cor e a fonte desejadas para nossas páginas:

      ~/node_project/views/css/styles.css

      .navbar {
              margin-bottom: 0;
      }
      
      body {
              background: #020A1B;
              color: #ffffff;
              font-family: 'Merriweather', sans-serif;
      }
      h1,
      h2 {
              font-weight: bold;
      }
      p {
              font-size: 16px;
              color: #ffffff;
      }
      
      
      .jumbotron {
              background: #0048CD;
              color: white;
              text-align: center;
      }
      .jumbotron p {
              color: white;
              font-size: 26px;
      }
      
      .btn-primary {
              color: #fff;
              text-color: #000000;
              border-color: white;
              margin-bottom: 5px;
      }
      
      img, video, audio {
              margin-top: 20px;
              max-width: 80%;
      }
      
      div.caption: {
              float: left;
              clear: both;
      }
      

      Inicie o aplicativo:

      Use seu navegador para ir para o endereço http://your_server_ip:8080 ou localhost:8080, se estiver trabalhando localmente. Você verá a seguinte página inicial:

      Página inicial do aplicativo

      Clique no botão Get Shark Info. Você verá a seguinte página de informações:

      Página de informações sobre tubarões

      Agora, você tem um aplicativo em funcionamento. Quando estiver pronto, saia do servidor, digitando CTRL+C.

      Passo 3 — Escrevendo o Dockerfile

      No diretório raiz do seu projeto, crie o Dockerfile:

      Adicione o código a seguir ao arquivo:

      ~/node_project/Dockerfile

      
      FROM node:10-alpine
      
      RUN mkdir -p /home/node/app/node_modules && chown -R node:node /home/node/app
      
      WORKDIR /home/node/app
      
      COPY package*.json ./
      
      USER node
      
      RUN npm install
      
      COPY --chown=node:node . .
      
      EXPOSE 8080
      
      CMD [ "node", "app.js" ]
      

      Esse Dockerfile utiliza uma imagem base alpine, assegurando que o usuário node não raiz detenha a propriedade dos arquivos do aplicativo. Por padrão, a imagem Node do Docker inclui o usuário node não raiz.

      Em seguida, adicione seus módulos node locais, os registros npm, o Dockerfile e o .dockerignore ao seu arquivo .dockerignore:

      ~/node_project/.dockerignore

      node_modules
      npm-debug.log
      Dockerfile
      .dockerignore
      

      Compile a imagem do aplicativo usando o comando docker build:

      • docker build -t your_dockerhub_username/nodejs-image-demo .

      O . especifica que o contexto de compilação é o diretório atual.

      Verifique suas imagens:

      Você verá o seguinte resultado:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 8 seconds ago 895MB node 10 f09e7c96b6de 17 hours ago 893MB

      Execute o comando a seguir para compilar um contêiner usando esta imagem:

      • docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

      Usando o docker ps, verifique a lista dos contêineres em execução:

      Você verá o seguinte resultado:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES e50ad27074a7 your_dockerhub_username/nodejs-image-demo "npm start" 8 seconds ago Up 7 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

      Com seu contêiner em execução, agora você pode acessar o seu aplicativo, utilizando seu navegador para acessar o endereço http://your_server_ip ou o localhost. Você verá a página inicial do seu aplicativo novamente:

      Página inicial do aplicativo

      Agora que você criou uma imagem para seu aplicativo, é possível encaminhá-la para o Docker Hub para uso futuro.

      O primeiro passo para enviar a imagem é fazer o login na sua conta do Docker Hub:

      • docker login -u your_dockerhub_username -p your_dockerhub_password

      Acessar dessa maneira criará um arquivo ~/.docker/config.json no diretório home do seu usuário, com as suas credenciais do Docker Hub.

      Envie sua imagem, usando seu próprio nome de usuário no lugar de your_dockerhub_username:

      • docker push your_dockerhub_username/nodejs-image-demo

      Se quiser, teste o utilitário do registro de imagens, destruindo o contêiner e a imagem atuais do seu aplicativo; depois, recompile-os.

      Primeiro, liste os contêineres em execução:

      Você verá o seguinte resultado:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES e50ad27074a7 your_dockerhub_username/nodejs-image-demo "npm start" 3 minutes ago Up 3 minutes 0.0.0.0:80->8080/tcp nodejs-image-demo

      Usar o CONTAINER ID listada em sua saída interromperá o contêiner do aplicativo em execução. Certifique-se de substituir o ID destacado abaixo pelo seu próprio CONTAINER ID:

      Liste todas as suas imagens com o sinalizador -a:

      Você verá o seguinte resultado com o nome de sua imagem, your_dockerhub_username/nodejs-image-demo, junto com a imagem node e outras imagens da sua compilação:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 7 minutes ago 895MB <none> <none> e039d1b9a6a0 7 minutes ago 895MB <none> <none> dfa98908c5d1 7 minutes ago 895MB <none> <none> b9a714435a86 7 minutes ago 895MB <none> <none> 51de3ed7e944 7 minutes ago 895MB <none> <none> 5228d6c3b480 7 minutes ago 895MB <none> <none> 833b622e5492 8 minutes ago 893MB <none> <none> 5c47cc4725f1 8 minutes ago 893MB <none> <none> 5386324d89fb 8 minutes ago 893MB <none> <none> 631661025e2d 8 minutes ago 893MB node 10 f09e7c96b6de 17 hours ago 893MB

      Usando o comando abaixo, remova o contêiner suspenso e todas as imagens, incluindo as imagens não utilizadas ou pendentes:

      Com todas as suas imagens e contêineres excluídos, agora você poderá extrair a imagem do aplicativo do Docker Hub:

      • docker pull your_dockerhub_username/nodejs-image-demo

      Liste as suas imagens novamente:

      Você verá a imagem do seu aplicativo:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE your_dockerhub_username/nodejs-image-demo latest 1c723fb2ef12 11 minutes ago 895MB

      Agora, você pode recompilar seu contêiner, usando o comando do Passo 3:

      • docker run --name nodejs-image-demo -p 80:8080 -d your_dockerhub_username/nodejs-image-demo

      Liste seus contêineres em execução:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES f6bc2f50dff6 your_dockerhub_username/nodejs-image-demo "npm start" 4 seconds ago Up 3 seconds 0.0.0.0:80->8080/tcp nodejs-image-demo

      Acesse novamente o http://your_server_ip ou o localhost para visualizar seu aplicativo em execução.

      Tutoriais relacionados

      Aqui estão os links para os guias mais detalhados relacionados a este tutorial:

      Você também pode revisar a série mais extensa do artigo intitulado De contêineres a Kubernetes com o Node.js, a partir da qual este tutorial foi adaptado.

      Além disso, consulte nossa biblioteca completa dos Recursos do Docker para obter mais detalhes sobre o Docker.



      Source link

      Como configurar os hosts virtuais do Apache no Ubuntu 18.04 [Guia de início rápido]


      Introdução

      Este tutorial irá guiá-lo na configuração de vários domínios e sites usando hosts virtuais do Apache em um servidor Ubuntu 18.04. Durante esse processo, você aprenderá como distribuir conteúdo diferente para visitantes diferentes, dependendo de quais domínios eles estiverem solicitando.

      Para uma versão mais detalhada deste tutorial, com mais explicações de cada passo, consulte o tutorial sobre Como configurar hosts virtuais do Apache no Ubuntu 18.04.

      Pré-requisitos

      Para completar este tutorial, será necessário ter acesso ao seguinte em um servidor Ubuntu 18.04:

      • Um usuário sudo no seu servidor
      • Um servidor Web Apache2, que pode ser instalado com sudo apt install apache2

      Passo 1 — Criar a estrutura de diretório

      Primeiro, vamos criar uma estrutura de diretórios que retenha os dados do site que vamos distribuir aos visitantes em nosso diretório Apache de nível superior. Vamos usar exemplos de nomes de domínio, conforme destacadosabaixo. Você deverá substituí-los por seus próprios nomes de domínio.

      • sudo mkdir -p /var/www/example.com/public_html
      • sudo mkdir -p /var/www/test.com/public_html

      Passo 2 — Conceder permissões

      Agora, devemos alterar as permissões para que nosso usuário não raiz atual consiga modificar os arquivos.

      • sudo chown -R $USER:$USER /var/www/example.com/public_html
      • sudo chown -R $USER:$USER /var/www/test.com/public_html

      Além disso, vamos garantir que o acesso de leitura seja concedido ao diretório Web geral – e todos os arquivos e pastas que ele contém, para que as páginas possam ser atendidas corretamente.

      • sudo chmod -R 755 /var/www

      Passo 3 — Criar páginas de demonstração para cada host virtual

      Vamos criar um conteúdo para distribuir. Além disso, criaremos uma página index.html de demonstração para cada site. Podemos abrir um arquivo index.html em um editor de texto para nosso primeiro site, usando o nano por exemplo.

      • nano /var/www/example.com/public_html/index.html

      Dentro desse arquivo, crie um documento HTML específico do domínio, como o seguinte:

      /var/www/example.com/public_html/index.html

      <html>
        <head>
          <title>Welcome to Example.com!</title>
        </head>
        <body>
          <h1>Success! The example.com virtual host is working!</h1>
        </body>
      </html>
      

      Salve e feche o arquivo e, em seguida, copie esse arquivo para usar como base para nosso segundo site:

      • cp /var/www/example.com/public_html/index.html /var/www/test.com/public_html/index.html

      Abra o arquivo e modifique as informações relevantes:

      • nano /var/www/test.com/public_html/index.html

      /var/www/test.com/public_html/index.html

      <html>
        <head>
          <title>Welcome to Test.com!</title>
        </head>
        <body> <h1>Success! The test.com virtual host is working!</h1>
        </body>
      </html>
      

      Salve e feche esse arquivo também.

      Passo 4 — Criar arquivos do host virtual

      O Apache vem com um arquivo de host virtual padrão chamado 000-default.conf que usaremos como modelo. Vamos copiá-lo para criar um arquivo de host virtual para cada um dos nossos domínios.

      Crie o primeiro arquivo de host virtual

      Comece copiando o arquivo para o primeiro domínio:

      • sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/example.com.conf

      Abra o novo arquivo no seu editor (estamos usando o nano abaixo) com privilégios raiz:

      • sudo nano /etc/apache2/sites-available/example.com.conf

      Vamos personalizar esse arquivo para nosso próprio domínio. Modifique o texto destacado abaixo de acordo com suas próprias necessidades suas próprias circunstâncias.

      /etc/apache2/sites-available/example.com.conf

      <VirtualHost *:80>
          ServerAdmin admin@example.com
          ServerName example.com
          ServerAlias www.example.com
          DocumentRoot /var/www/example.com/public_html
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Neste ponto, salve e feche o arquivo.

      Copiar o primeiro host virtual e personalizar para o segundo domínio

      Agora que temos o nosso primeiro arquivo de host virtual estabelecido, podemos criar nosso segundo, copiando aquele arquivo e ajustando o arquivo, conforme necessário.

      Comece copiando-o:

      • sudo cp /etc/apache2/sites-available/example.com.conf /etc/apache2/sites-available/test.com.conf

      Abra o novo arquivo com privilégios raiz em seu editor:

      • sudo nano /etc/apache2/sites-available/test.com.conf

      Agora, será necessário modificar todas as informações para referenciar seu segundo domínio. O arquivo final deve se parecer com este, com o texto destacado correspondendo às suas próprias informações de domínio relevantes.

      /etc/apache2/sites-available/test.com.conf

      <VirtualHost *:80>
          ServerAdmin admin@test.com
          ServerName test.com
          ServerAlias www.test.com
          DocumentRoot /var/www/test.com/public_html
          ErrorLog ${APACHE_LOG_DIR}/error.log
          CustomLog ${APACHE_LOG_DIR}/access.log combined
      </VirtualHost>
      

      Salve e feche o arquivo quando você terminar.

      Passo 5 — Habilitar os novos arquivos de host virtual

      Com nossos arquivos de host virtual criados, precisamos habilitá-los. Vamos usar a ferramenta a2ensite para alcançar esse objetivo.

      • sudo a2ensite example.com.conf
      • sudo a2ensite test.com.conf

      Em seguida, desabilite o site padrão definido em 000-default.conf:

      • sudo a2dissite 000-default.conf

      Quando terminar, será necessário reiniciar o Apache para essas alterações fazerem efeito e usar o systemctl status para verificar o sucesso da reinicialização.

      • sudo systemctl restart apache2

      Agora, seu servidor deve estar configurado para atender dois sites.

      Passo 6 — Configurar o arquivo de hosts locais (opcional)

      Se você ainda não estiver usando seus próprios nomes de domínios para testar esse procedimento, mas venha usando alguns exemplos domínios, você poderá testar o seu trabalho, alterando temporariamente o arquivo hosts em seu computador local.

      Em uma máquina local Mac ou Linux, digite o seguinte:

      Para uma máquina local Windows, encontre instruções sobre como alterar o arquivo hosts aqui.

      Utilizando os domínios usados neste guia e substituindo o IP do seu servidor pelo texto your_server_IP, seu arquivo deverá ficar com a seguinte aparência:

      /etc/hosts

      127.0.0.1   localhost
      127.0.1.1   guest-desktop
      your_server_IP example.com
      your_server_IP test.com
      

      Salve e feche o arquivo. Isso direcionará quaisquer pedidos para o example.com e o test.com em nosso computador e os enviará para nosso servidor.

      Passo 7 — Testar seus resultados

      Agora que seus hosts virtuais estão configurados, você pode testar suas configurações, acessando os domínios que configurou em seu navegador Web.

      http://example.com
      

      Você deve ver uma página como esta:

      Exemplo de host virtual do Apache

      Você também pode acessar sua segunda página e ver o arquivo que criou para seu segundo site.

      http://test.com
      

      Teste do host virtual do Apache

      Caso ambos esses sites funcionarem conforme o esperado, significa que você configurou dois hosts virtuais no mesmo servidor.

      Caso tenha ajustado o arquivo hosts do seu computador caseiro, exclua as linhas que adicionou.

      Tutoriais relacionados

      Aqui estão os links para outros guias relacionados a este tutorial:



      Source link

      How To Install Software on Kubernetes Clusters with the Helm 3 Package Manager


      Introduction

      Helm is a package manager for Kubernetes that allows developers and operators to more easily configure and deploy applications on Kubernetes clusters.

      In this tutorial, you will set up Helm 3 and use it to install, reconfigure, rollback, and delete an instance of the Kubernetes Dashboard application. The dashboard is an official web-based Kubernetes GUI.

      For a conceptual overview of Helm and its packaging ecosystem, please read our article, An Introduction to Helm.

      Prerequisites

      For this tutorial you will need:

      • A Kubernetes cluster with role-based access control (RBAC) enabled. Helm 3.1 supports clusters from versions 1.14 to 1.17. For further information check the Helm releases page.
      • The kubectl command-line tool installed on your local machine, configured to connect to your cluster. You can read more about installing kubectl in the official documentation.

        You can test your connectivity with the following command:

        If you see no errors, you’re connected to the cluster. If you access multiple clusters with kubectl, be sure to verify that you’ve selected the correct cluster context:

        • kubectl config get-contexts

        Output

        CURRENT NAME CLUSTER AUTHINFO NAMESPACE * do-fra1-helm3-example do-fra1-helm3-example do-fra1-helm3-example-admin

        In this example the asterisk (*) indicates that we are connected to the do-fra1-helm3-example cluster. To switch clusters run:

        • kubectl config use-context context-name

      When you are connected to the correct cluster, continue to Step 1 to begin installing Helm.

      Step 1 — Installing Helm

      First, you’ll install the helm command-line utility on your local machine. Helm provides a script that handles the installation process on MacOS, Windows, or Linux.

      Change to a writable directory and download the script from Helm’s GitHub repository:

      • cd /tmp
      • curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3

      Make the script executable with chmod:

      You can use your favorite text editor to open the script and inspect it to make sure it’s safe. When you are satisfied, run it:

      You may be prompted for your password. Provide it and press ENTER to continue.

      The output will look like this:

      Output

      Downloading https://get.helm.sh/helm-v3.1.2-linux-amd64.tar.gz Preparing to install helm into /usr/local/bin helm installed into /usr/local/bin/helm

      Now that you’ve got Helm installed, you’re ready to use Helm to install your first chart.

      Step 2 — Installing a Helm Chart

      Helm software packages are called charts. There is a curated chart repository called stable, mostly consisting of common charts, which you can see in their GitHub repo. Helm does not come preconfigured for it, so you’ll need to manually add it. Then, as an example, you are going to install the Kubernetes Dashboard.

      Add the stable repo by running:

      • helm repo add stable https://kubernetes-charts.storage.googleapis.com

      The output will be:

      Output

      "stable" has been added to your repositories

      Then, use helm to install the kubernetes-dashboard package from the stable repo:

      • helm install dashboard-demo stable/kubernetes-dashboard --set rbac.clusterAdminRole=true

      The --set parameter lets you to customize chart variables, which the chart exposes to allow you to customize its configuration. Here, you set the rbac.clusterAdminRole variable to true to grant the Kubernetes Dashboard access to your whole cluster.

      The output will look like:

      Output

      NAME: dashboard-demo LAST DEPLOYED: Tue Mar 31 15:04:19 2020 NAMESPACE: default STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: ...

      Notice the NAME line, highlighted in the above example output. In this case, you specified the name dashboard-demo. This is the name of the release. A Helm release is a single deployment of one chart with a specific configuration. You can deploy multiple releases of the same chart, each with its own configuration.

      You can list all the releases in the cluster:

      The output will be similar to this:

      Output

      NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION dashboard-demo default 1 2020-03-31 15:04:19.324774799 +0000 UTC deployed kubernetes-dashboard-1.10.1 1.10.1

      You can now use kubectl to verify that a new service has been deployed on the cluster:

      The output will look like this:

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE dashboard-demo-kubernetes-dashboard ClusterIP 10.245.115.214 <none> 443/TCP 4m44s kubernetes ClusterIP 10.245.0.1 <none> 443/TCP 19m

      Notice that by default, the service name corresponding to the release is a combination of the Helm release name and the chart name.

      Now that you’ve deployed the application, you’ll use Helm to change its configuration and update the deployment.

      Step 3 — Updating a Release

      The helm upgrade command can be used to upgrade a release with a new or updated chart, or update its configuration options (variables).

      You’re going to make a simple change to the dashboard-demo release to demonstrate the update and rollback process: you’ll update the name of the dashboard service to just kubernetes-dashboard, instead of dashboard-demo-kubernetes-dashboard.

      The kubernetes-dashboard chart provides a fullnameOverride configuration option to control the service name. To rename the release, run helm upgrade with this option set:

      • helm upgrade dashboard-demo stable/kubernetes-dashboard --set fullnameOverride="kubernetes-dashboard" --reuse-values

      By passing in the --reuse-values argument, you make sure that chart variables you’ve previously set do not get reset by the upgrade process.

      You’ll see output similar to the initial helm install step.

      Check if your Kubernetes services reflect the updated values:

      The output will look like the following:

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.245.0.1 <none> 443/TCP 38m kubernetes-dashboard ClusterIP 10.245.49.157 <none> 443/TCP 8s

      Notice that the service name has been updated to the new value.

      Note: At this point you may want to actually load the Kubernetes Dashboard in your browser and check it out. To do so, first run the following command:

      This creates a proxy that lets you access remote cluster resources from your local computer. Based on the previous instructions, your dashboard service is named kubernetes-dashboard and it’s running in the default namespace. You may now access the dashboard at the following URL:

      http://localhost:8001/api/v1/namespaces/default/services/https:kubernetes-dashboard:https/proxy/
      

      Instructions for actually using the dashboard are out of scope for this tutorial, but you can read the official Kubernetes Dashboard docs for more information.

      Next, you’ll have a look at Helm’s ability to roll back and delete releases.

      Step 4 — Rolling Back and Deleting a Release

      When you updated the dashboard-demo release in the previous step, you created a second revision of the release. Helm retains all the details of previous releases in case you need to roll back to a prior configuration or chart.

      Use helm list to inspect the release again:

      You’ll see the following output:

      Output

      NAME REVISION UPDATED STATUS CHART NAMESPACE dashboard-demo 2 Wed Aug 8 20:13:15 2018 DEPLOYED kubernetes-dashboard-0.7.1 default

      The REVISION column tells you that this is now the second revision.

      Use helm rollback to roll back to the first revision:

      • helm rollback dashboard-demo 1

      You should see the following output, indicating that the rollback succeeded:

      Output

      Rollback was a success! Happy Helming!

      At this point, if you run kubectl get services again, you will notice that the service name has changed back to its previous value. Helm has re-deployed the application with revision 1’s configuration.

      Helm releases can be deleted with the helm delete command:

      • helm delete dashboard-demo

      The output will be:

      Output

      release "dashboard-demo" uninstalled

      You can try listing Helm releases:

      You’ll see that there are none:

      Output

      NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION

      Now the release has been truly deleted, and you can reuse the release name.

      Conclusion

      In this tutorial, you installed the helm command-line tool and explored installing, upgrading, rolling back, and deleting Helm charts and releases by managing the kubernetes-dashboard chart.

      For more information about Helm and Helm charts, please see the official Helm documentation.



      Source link