One place for hosting & domains

      Volumes

      Como Remover Imagens Docker, Contêineres e Volumes


      Um Guia de Consulta Rápida do Docker

      Introdução

      O Docker facilita o agrupamento de suas aplicações e serviços em contêineres de forma que você possa executá-los em qualquer lugar. Ao trabalhar com o Docker, no entanto, também é fácil acumular um número excessivo de imagens, contêineres e volumes de dados não utilizados que atrapalham a saída e consomem espaço em disco.

      O Docker lhe fornece todas as ferramentas que você precisa para limpar seu sistema a partir da linha de comando. Este guia no estilo cheat sheet fornece uma referência rápida para comandos que são úteis para liberar espaço em disco e manter seu sistema organizado, removendo imagens Docker não utilizadas, contêineres e volumes.

      Como Usar Este Guia:

      • Este guia está no formato de consulta rápida, com trechos de linha de comando independentes.
      • Vá para qualquer seção que seja relevante para a tarefa que você está tentando concluir.

      A sintaxe de substituição de comando, comando $(comando), usada nos comandos está disponível em muitos shells populares, como o bash, zsh e Windows Powershell.

      Limpando Todas as Imagens, Contêineres, Volumes e Redes não Utilizadas ou Pendentes

      O Docker fornece um único comando que irá limpar quaisquer recursos — imagens, contêineres, volumes, e redes — que estão pendentes (não associados a um contêiner):

      Para remover adicionalmente quaisquer contêineres e todas as imagens não utilizadas (não apenas imagens pendentes), adicione a flag -a ao comando:

      Removendo Imagens Docker

      Remover uma ou mais imagens específicas

      Use o comando docker images com a flag -a para localizar o ID das imagens que você deseja remover. Isso lhe mostrará todas as imagens, incluindo camadas intermediárias de imagem. Quando você tiver localizado as imagens que deseja excluir, você pode passar o ID ou tag delas para o docker rmi:

      Listar:

      Remover:

      Remover imagens pendentes

      As imagens Docker consistem de várias camadas. As imagens pendentes são camadas que não têm relação com nenhuma imagem marcada. Elas não servem a um propósito e consomem espaço em disco. Elas podem ser localizadas adicionando a sinalização de filtro, -f com um valor de dangling=true ao comando docker images. Quando você tiver certeza de que deseja excluí-las, você pode usar o comando docker images purge:

      Nota: se você construir uma imagem sem marcá-la, ela aparecerá na lista de imagens pendentes porque ela não possui nenhuma associação com uma imagem marcada. Você pode evitar esta situação fornecendo uma tag quando você for compilar, e você marcar retroativamente uma imagem com o comando docker tag.

      Listar:

      • docker images -f dangling=true

      Remover:

      Removendo imagens de acordo com um padrão

      Você pode encontrar todas as imagens que correspondem a um padrão usando uma combinação do docker images e grep. Assim que estiver satisfeito, você pode excluí-las usando o awk para passar os IDs para o docker rmi. Observe que esses utilitários não são fornecidos pelo Docker e não estão necessariamente disponíveis em todos os sistemas:

      Listar:

      • docker images -a | grep "pattern"

      Remover:

      • docker images -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

      Remover todas as imagens

      Todas as imagens Docker em um sistema podem ser listadas adicionando -a ao comando docker images. Assim que tiver certeza de que você deseja excluir todas elas, você pode adicionar a sinalização -q para passar o ID da Imagem para o docker rmi:

      Listar:

      Remover:

      • docker rmi $(docker images -a -q)

      Removendo Contêineres

      Remover um ou mais contêineres específicos

      Use o comando docker ps com a sinalização -a para localizar o nome e o ID dos contêineres que você deseja remover.

      Listar:

      Remover:

      • docker rm ID_or_Name ID_or_Name

      Remover um contêiner ao sair

      Se você sabe, ao criar um contêiner, que você não irá querer mantê-lo por perto assim que terminar, você pode executar docker run --rm para excluí-lo automaticamente quando ele for fechado.

      Executar e Remover:

      • docker run --rm image_name

      Remover todos os contêineres finalizados

      Você pode localizar contêineres usando o docker ps -a e filtrá-los pelo seu status: created, restarting, running, paused, or exited. Para revisar a lista de contêineres finalizados, use a flag -f para filtrar com base no status. Quando você tiver verificado, você deseja remover esses contêineres, usando -q para passar os IDs para o comando docker rm.

      Listar:

      • docker ps -a -f status=exited

      Remover:

      • docker rm $(docker ps -a -f status=exited -q)

      Remover contêineres usando mais de um filtro.

      Os filtros do Docker podem ser combinados repetindo a sinalização de filtro com um valor adicional. Isso resulta em uma lista de contêineres que correspondem a qualquer das condições. Por exemplo, se você quiser excluir todos contêineres marcados como Created (um estado que pode resultar quando você executa um contêiner com um comando inválido) ou Exited, você pode usar dois filtros:

      Listar:

      • docker ps -a -f status=exited -f status=created

      Remover:

      • docker rm $(docker ps -a -f status=exited -f status=created -q)

      Remover contêineres de acordo com um padrão

      Você pode encontrar todos os contêineres que correspondem a um padrão usando uma combinação de docker ps e grep. Quando você estiver satisfeito com a lista que deseja excluir, você pode usar o awk e o xargs para fornecer o ID para o docker rmi. Observe que esses utilitários não são fornecidos pelo Docker e não estão necessariamente disponíveis em todos os sistemas:

      Listar:

      • docker ps -a | grep "pattern

      Remover:

      • docker ps -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

      Parar e remover todos os contêineres

      Você pode revisar os contêineres em seu sistema com o docker ps. Adicionando a flag -a mostrará todos os contêineres. Quando você tiver certeza de que deseja excluí-los, você pode adicionar a flag -q para fornecer os IDs para os comandos docker stop e docker rm:

      Listar:

      Remover:

      • docker stop $(docker ps -a -q)
      • docker rm $(docker ps -a -q)

      Removendo Volumes

      Remover um ou mais volumes específicos – Docker 1.9 e mais recentes

      Use o comando docker volume ls para localizar o nome ou nomes de volume que você deseja excluir. Em seguida, você pode remover um ou mais volumes com o comando docker volume rm:

      Listar:

      Remover:

      • docker volume rm volume_name volume_name

      Remover volumes pendentes – Docker 1.9 e acima

      Como a ideia de volumes é existir independentemente dos contêineres, quando um contêiner é removido, um volume não é removido automaticamente ao mesmo tempo. Quando um volume existe e não está mais conectado a nenhum contêiner, ele é chamado de volume pendente, ou dangling volume. Para localizá-los para confirmar que você deseja removê-los, você pode usar o comando docker volume ls com um filtro para limitar os resultados aos volumes pendentes. Quando você estiver satisfeito com a lista, você pode remover todos eles com docker volume prune:

      Listar:

      • docker volume ls -f dangling=true

      Remover:

      Remover um contêiner e seu volume

      Se você criou um volume não nomeado, ele pode ser excluído ao mesmo tempo que o contêiner com a sinalização -v. Observe que isso funciona apenas com volumes não nomeados. Quando o contêiner for removido com sucesso, seu ID é exibido. Observe que nenhuma referência é feita à remoção do volume. Se ele está sem nome, ele é removido silenciosamente do sistema. Se ele está nomeado, ele permanece silenciosamente presente.

      Remover:

      • docker rm -v container_name

      Conclusão

      Este guia cobre alguns dos comandos comuns usados para remover imagens, contêineres e volumes com o Docker. Há muitas outras combinações e flags que podem ser usadas com cada um deles. Para um guia abrangente sobre o que está disponível, consulte a documentação do Docker para docker system prune, docker rmi, docker rm, e docker volume rm. Se houver tarefas comuns de limpeza que você gostaria de ver no guia, por favor, pergunte ou faça sugestões nos comentários.



      Source link

      So richten Sie ReadWriteMany (RWX) Persistent Volumes mit NFS unter DigitalOcean Kubernetes ein


      Einführung

      Aufgrund der verteilten und dynamischen Natur von Containern ist die statische Verwaltung und Konfiguration von Speicher in Kubernetes zu einem schwierigen Problem geworden, da Arbeitslasten jetzt in der Lage sind, innerhalb von Sekunden von einer virtuellen Maschine (VM) auf eine andere zu wechseln. Um dieses Problem zu lösen, verwaltet Kubernetes Volumes mit einem System aus Persistent Volumes (PV), API-Objekten, die eine Speicherkonfiguration/ein Volume darstellen, und PersistentVolumeClaims (PVC), einer Speicheranforderung, die von einem Persistent Volume erfüllt werden soll. Darüber hinaus können Container Storage Interface (CSI)-Treiber dazu beitragen, die Handhabung und Bereitstellung von Speicher für containerisierte Workloads zu automatisieren und zu verwalten. Diese Treiber sind für die Bereitstellung, das Einbinden, das Aufheben der Einbindung, das Entfernen und das Erstellen von Snapshots von Volumes verantwortlich.

      Das digitalocean-csi integriert einen Kubernetes-Cluster mit dem Produkt DigitalOcean Block Storage. Damit kann ein Entwickler Blockspeicher-Volumes für containerisierte Anwendungen in Kubernetes dynamisch bereitstellen. Anwendungen können jedoch manchmal erfordern, dass Daten über mehrere Droplets hinweg persistent gespeichert und gemeinsam genutzt werden. Die Blockspeicher-CSI-Standardlösung von DigitalOcean ist nicht in der Lage, das gleichzeitige Einbinden eines Blockspeicher-Volumes in mehrere Droplets zu unterstützen. Dies bedeutet, dass es sich um eine ReadWriteOnce (RWO)-Lösung handelt, da das Volume auf einen Knoten beschränkt ist. Das Protokoll Network File System (NFS) hingegen unterstützt das Exportieren derselben Freigabe an viele Consumer. Dies wird ReadWriteMany (RWX) genannt, da viele Knoten das Volume als Read-Write einbinden können. Wir können daher einen NFS-Server innerhalb unseres Clusters verwenden, um Speicher bereitzustellen, der die zuverlässige Unterstützung von DigitalOcean Block Storage mit der Flexibilität von NFS-Freigaben nutzen kann.

      In diesem Tutorial werden Sie die dynamische Bereitstellung für NFS-Volumes innerhalb eines DigitalOcean Kubernetes (DOKS)-Clusters, in dem die Exporte auf DigitalOcean Block-Speichervolumes gespeichert werden, konfigurieren. Anschließend werden Sie mehrere Instanzen einer Nginx-Demoanwendung bereitstellen und die gemeinsame Nutzung von Daten zwischen den einzelnen Instanzen testen.

      Voraussetzungen

      Bevor Sie mit diesem Leitfaden beginnen, benötigen Sie Folgendes:

      • Die auf Ihrem lokalen Rechner installierte Befehlszeilenschnittstelle kubectl. Mehr über die Installation und Konfiguration von kubectl können Sie der offiziellen Dokumentation entnehmen.

      • Einen DigitalOcean Kubernetes-Cluster, bei dem Ihre Verbindung standardmäßig als kubectl konfiguriert ist. Um einen Kubernetes-Cluster auf DigitalOcean zu erstellen, lesen Sie unseren Kubernetes-Schnellstart. Eine Anleitung zur Konfiguration von kubectl finden Sie unter dem Schritt Verbinden mit Ihrem Cluster, wenn Sie Ihren Cluster erstellen.

      • Den auf Ihrem lokalen Rechner installierten Helm-Paketmanager und das auf Ihrem Cluster installierte Tiller. Führen Sie dazu die Schritte 1 und 2 des Tutorials So installieren Sie Software auf Kubernetes Clustern mit dem Helm-Paketmanager aus.

      Hinweis: Ab Helm Version 3.0 muss Tiller nicht mehr installiert werden, damit Helm funktioniert. Wenn Sie die neueste Version von Helm verwenden, finden Sie die Anweisungen in der Helm-Installationsdokumentation.

      Schritt 1 – Bereitstellen des NFS-Servers mit Helm

      Für die Bereitstellung des NFS-Servers verwenden Sie ein Helm Chart. Die Bereitstellung eines Helm Charts ist eine automatisierte Lösung, die schneller und weniger fehleranfällig ist als die manuelle Erstellung der NFS-Serverbereitstellung.

      Stellen Sie zuerst sicher, dass das standardmäßige Chart-Repository stable verfügbar ist, indem Sie das Repo hinzufügen:

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

      Als Nächstes rufen Sie die Metadaten für das Repository ab, das Sie gerade hinzugefügt haben. Dadurch wird sichergestellt, dass der Helm-Client aktualisiert wird:

      Um den Zugriff auf das Repo stable zu verifizieren, führen Sie eine Suche in den Charts aus:

      Dadurch erhalten Sie eine Liste der verfügbaren Charts, ähnlich der folgenden:

      Output

      NAME CHART VERSION APP VERSION DESCRIPTION stable/acs-engine-autoscaler 2.2.2 2.1.1 DEPRECATED Scales worker nodes within agent pools stable/aerospike 0.3.2 v4.5.0.5 A Helm chart for Aerospike in Kubernetes stable/airflow 5.2.4 1.10.4 Airflow is a platform to programmatically autho... stable/ambassador 5.3.0 0.86.1 A Helm chart for Datawire Ambassador ...

      Das Ergebnis bedeutet, dass Ihr Helm-Client ausgeführt wird und auf dem neuesten Stand ist.

      Nachdem Helm nun eingerichtet ist, installieren Sie das Helm Chart nfs-server-provisioner, um den NFS-Server einzurichten. Wenn Sie den Inhalt des Charts untersuchen möchten, werfen Sie einen Blick in seine Dokumentation auf GitHub.

      Wenn Sie das Helm-Chart bereitstellen, legen Sie einige Variablen für Ihren NFS-Server fest, um die Konfiguration für Ihre Anwendung weiter zu spezifizieren. Sie können auch andere Konfigurationsoptionen untersuchen und sie an die Bedürfnisse der Anwendung anpassen.

      Verwenden Sie den folgenden Befehl, um das Helm-Chart zu installieren:

      • helm install nfs-server stable/nfs-server-provisioner --set persistence.enabled=true,persistence.storageClass=do-block-storage,persistence.size=200Gi

      Dieser Befehl stellt einen NFS-Server mit den folgenden Konfigurationsoptionen bereit:

      • Fügt ein Persistent Volume für den NFS-Server mit dem Flag --set hinzu. Dadurch wird sichergestellt, dass alle gemeinsam genutzten NFS-Daten auch bei Pod-Neustarts persistent gespeichert sind.
      • Für die persistente Speicherung wird die Speicherklasse do-block-storage verwendet.
      • Stellt insgesamt 200Gi für den NFS-Server bereit, die in Exporte aufgeteilt werden können.

      Hinweis: Die Option persistence.size bestimmt die Gesamtkapazität aller NFS-Volumes, die Sie bereitstellen können. Zum Zeitpunkt dieser Veröffentlichung unterstützen nur die DOKS Version 1.16.2-do.3 und spätere Versionen die Erweiterung von Volumes, sodass die Größenänderung dieses Volumes eine manuelle Aufgabe ist, wenn Sie eine frühere Version verwenden. Stellen Sie in diesem Fall sicher, dass Sie diese Größe im Hinblick auf Ihre zukünftigen Bedürfnisse einstellen.

      Nachdem dieser Befehl abgeschlossen ist, erhalten Sie eine Ausgabe, die der folgenden ähnelt:

      Output

      NAME: nfs-server LAST DEPLOYED: Thu Feb 13 19:30:07 2020 NAMESPACE: default STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: The NFS Provisioner service has now been installed. A storage class named 'nfs' has now been created and is available to provision dynamic volumes. You can use this storageclass by creating a PersistentVolumeClaim with the correct storageClassName attribute. For example: --- kind: PersistentVolumeClaim apiVersion: v1 metadata: name: test-dynamic-volume-claim spec: storageClassName: "nfs" accessModes: - ReadWriteOnce resources: requests: storage: 100Mi

      Um den von Ihnen bereitgestellten NFS-Server zu sehen, führen Sie den folgenden Befehl aus:

      Dadurch wird Folgendes angezeigt:

      Output

      NAME READY STATUS RESTARTS AGE nfs-server-nfs-server-provisioner-0 1/1 Running 0 11m

      Prüfen Sie als Nächstes die von Ihnen erstellte storageclass:

      Sie erhalten eine Ausgabe, die der folgenden ähnelt:

      Output

      NAME PROVISIONER AGE do-block-storage (default) dobs.csi.digitalocean.com 90m nfs cluster.local/nfs-server-nfs-server-provisioner 3m

      Sie haben nun einen NFS-Server sowie einen storageclass, die Sie für die dynamische Bereitstellung von Volumes verwenden können. Als Nächstes können Sie eine Bereitstellung erstellen, die diesen Speicher verwendet, und ihn über mehrere Instanzen hinweg gemeinsam nutzen.

      Schritt 2 – Bereitstellen einer Anwendung unter Verwendung eines gemeinsam genutzten PersistentVolumeClaim

      In diesem Schritt erstellen Sie eine beispielhafte Bereitstellung auf Ihrem DOKS-Cluster, um Ihre Speichereinrichtung zu testen. Dies wird eine Nginx Webserver-Anwendung namens web sein.

      Um diese Anwendung bereitzustellen, schreiben Sie zunächst die YAML-Datei, um die Bereitstellung zu spezifizieren. Öffnen Sie eine Datei nginx-test.yaml mit Ihrem Texteditor; dieses Tutorial verwendet nano:

      Fügen Sie in diese Datei die folgenden Zeilen ein, um die Bereitstellung mit einem PersistentVolumeClaim namens nfs-data zu definieren:

      nginx-test.yaml

      apiVersion: apps/v1
      kind: Deployment
      metadata:
        labels:
          app: web
        name: web
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: web
        strategy: {}
        template:
          metadata:
            creationTimestamp: null
            labels:
              app: web
          spec:
            containers:
            - image: nginx:latest
              name: nginx
              resources: {}
              volumeMounts:
              - mountPath: /data
                name: data
            volumes:
            - name: data
              persistentVolumeClaim:
                claimName: nfs-data
      ---
      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: nfs-data
      spec:
        accessModes:
        - ReadWriteMany
        resources:
          requests:
            storage: 2Gi
        storageClassName: nfs
      

      Speichern Sie die Datei und beenden Sie den Texteditor.

      Diese Bereitstellung ist so konfiguriert, dass sie die zugehörigen PersistentVolumeClaim nfs-data verwendet und sie unter /data einbindet.

      In der PVC-Definition werden Sie feststellen, dass der storageClassName auf nfs gesetzt ist. Damit wird dem Cluster mitgeteilt, dass er diese Speicherung nach den Regeln der nfs storageClass, die Sie im vorherigen Schritt erstellt haben, erfüllen muss. Der neue PersistentVolumeClaim wird verarbeitet und dann wird eine NFS-Freigabe bereitgestellt, um den Anspruch in Form eines Persistent Volumes zu erfüllen. Der Pod wird versuchen, dieses PVC einzubinden, sobald es bereitgestellt wurde. Nach dem Einbinden verifizieren Sie die Funktionalität ReadWriteMany (RWX).

      Führen Sie die Bereitstellung mit dem folgenden Befehl aus:

      • kubectl apply -f nginx-test.yaml

      Dadurch erhalten Sie folgende Ausgabe:

      Output

      deployment.apps/web created persistentvolumeclaim/nfs-data created

      Als Nächstes prüfen Sie, ob der Pod web anläuft:

      Dadurch wird Folgendes ausgegeben:

      Output

      NAME READY STATUS RESTARTS AGE nfs-server-nfs-server-provisioner-0 1/1 Running 0 23m web-64965fc79f-b5v7w 1/1 Running 0 4m

      Nachdem nun die Beispielbereitstellung läuft, können Sie sie mit dem Befehl kubectl scale auf drei Instanzen skalieren:

      • kubectl scale deployment web --replicas=3

      Dadurch erhalten Sie folgende Ausgabe:

      Output

      deployment.extensions/web scaled

      Führen Sie nun den Befehl kubectl get erneut aus:

      Sie finden die skalierten Instanzen der Bereitstellung:

      Output

      NAME READY STATUS RESTARTS AGE nfs-server-nfs-server-provisioner-0 1/1 Running 0 24m web-64965fc79f-q9626 1/1 Running 0 5m web-64965fc79f-qgd2w 1/1 Running 0 17s web-64965fc79f-wcjxv 1/1 Running 0 17s

      Sie haben nun drei Instanzen Ihrer Nginx-Bereitstellung, die mit demselben Persistent Volume verbunden sind. Im nächsten Schritt stellen Sie sicher, dass sie Daten untereinander gemeinsam nutzen können.

      Schritt 3 – Validieren der gemeinsamen Nutzung von NFS-Daten

      Im letzten Schritt überprüfen Sie, ob die Daten von allen Instanzen, die in die NFS-Freigabe eingebunden sind, gemeinsam genutzt werden. Dazu erstellen Sie eine Datei im Verzeichnis /data in einem der Pods und verifizieren dann, ob die Datei in dem Verzeichnis /data eines anderen Pods vorhanden ist.

      Um dies zu validieren, verwenden Sie den Befehl kubectl exec. Mit diesem Befehl können Sie einen Pod angeben und einen Befehl innerhalb dieses Pods ausführen. Um mehr über die Überprüfung von Ressourcen unter Verwendung von kubectl zu erfahren, werfen Sie einen Blick auf unseren kubectl-Spickzettel.

      Um innerhalb eines Ihrer Pods web eine Datei namens hello_world zu erstellen, verwenden Sie den Befehl kubectl exec, um den Befehl touch weiterzugeben. Beachten Sie, dass die Zahl nach web im Pod-Namen für Sie unterschiedlich sein wird. Achten Sie also darauf, den hervorgehobenen Pod-Namen durch einen Ihrer eigenen Pods zu ersetzen, die Sie im letzten Schritt als Ausgabe von kubectl get pods gefunden haben.

      • kubectl exec web-64965fc79f-q9626 -- touch /data/hello_world

      Ändern Sie dann den Namen des Pod und verwenden Sie den Befehl ls, um die Dateien im Verzeichnis /data eines anderen Pods aufzulisten:

      • kubectl exec web-64965fc79f-qgd2w -- ls /data

      Ihre Ausgabe zeigt die Datei an, die Sie im ersten Pod erstellt haben:

      Output

      hello_world

      Dies zeigt, dass alle Pods Daten über NFS gemeinsam nutzen und dass Ihre Einrichtung korrekt funktioniert.

      Zusammenfassung

      In diesem Tutorial haben Sie einen NFS-Server erstellt, der durch DigitalOcean Block Storage unterstützt wurde. Der NFS-Server verwendete dann diesen Blockspeicher zur Bereitstellung und zum Export von NFS-Freigaben für Workloads in einem RWX-kompatiblen Protokoll. Auf diese Weise konnten Sie eine technische Beschränkung der Blockspeicherung von DigitalOcean umgehen und dieselben PVC-Daten über viele Pods hinweg gemeinsam nutzen. Durch dieses Tutorial ist Ihr DOKS-Cluster nun so eingerichtet, dass er eine wesentlich größere Anzahl von Anwendungsfällen für die Bereitstellung unterstützt.

      Wenn Sie mehr über Kubernetes erfahren möchten, sehen Sie sich unser Curriculum für Full-Stack-Entwickler oder die Produktdokumentation für DigitalOcean Kubernetes an.



      Source link

      Como configurar os volumes persistentes ReadWriteMany (RWX) com NFS no Kubernetes da DigitalOcean


      Introdução

      Devido à natureza distribuída e dinâmica dos contêineres, gerenciar e configurar o armazenamento de maneira estática se transformou em um problema no Kubernetes, uma vez que agora as cargas de trabalho conseguem mover-se de uma máquina virtual (VM) para outra em questão de segundos. Para lidar com a questão, o Kubernetes gerencia os volumes com um sistema de Persistent Volumes (PV) (volumes persistentes), objetos de API que representam uma configuração de armazenamento/volume e de PersistentVolumeClaims (PVC), uma solicitação por armazenamento atendida por um volume persistente. Além disso, drivers da Interface de Armazenamento de Contêiner (CSI) podem ajudar a automatizar e gerenciar o manuseamento e fornecimento de armazenamento para cargas de trabalho em contêiner. Esses drivers são responsáveis pelo fornecimento, montagem, desmontagem, remoção e serviços de instantâneo de volumes.

      O digitalocean-csi integra um cluster do Kubernetes com o produto armazenamento em bloco da DigitalOcean. Um desenvolvedor pode usar isso para fornecer volumes de armazenamento de bloco dinamicamente para aplicativos em contêiner no Kubernetes. No entanto, os aplicativos podem, por vezes, exigir que dados sejam mantidos e partilhados por vários Droplets. A solução padrão CSI de armazenamento em bloco da DigitalOcean não consegue suportar a montagem de um volume de armazenamento de bloco em muitos Droplets simultaneamente. Isso significa que esta é uma solução ReadWriteOnce (RWO) (Ler e escrever uma vez), uma vez que o volume é limitado a um nó. O protocolo de Sistema de Arquivos de Rede (NFS), por outro lado, dá suporte à exportação da mesma quantidade a muitos consumidores. Isso se chama ReadWriteMany (RWX) (Ler e escrever muitos), pois muitos nós podem montar o volume como leitura-gravação. Assim, podemos usar um servidor NFS dentro do nosso cluster para fornecer armazenamento que pode potencializar o suporte confiável do armazenamento em bloco da DigitalOcean com a flexibilidade das quantidades do NFS.

      Neste tutorial, você irá configurar o fornecimento dinâmico de volumes NFS dentro de um cluster DigitalOcean Kubernetes (DOKS) no qual as exportações são armazenadas em volumes de armazenamento em bloco da DigitalOcean. Em seguida, implantará várias instâncias de um aplicativo de demonstração Nginx e testará o compartilhamento de dados entre cada instância.

      Pré-requisitos

      Antes de iniciar este guia, você precisará do seguinte:

      Nota: a partir da versão 3.0 do Helm, o Tiller já não precisa estar instalado para que o Helm funcione. Caso esteja usando a versão mais recente do Helm, consulte a documentação de instalação do Helm para obter instruções.

      Para implantar o servidor NFS, você usará um gráfico do Helm. Comparada à implantação manual do servidor NFS, a implantação de um gráfico do Helm se apresenta como uma solução automatizada mais rápida e menos suscetível a erros.

      Primeiro, certifique-se de que o repositório padrão de gráficos stable esteja disponível para você, adicionando o repo:

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

      Em seguida, puxe os metadados para o repositório que acabou de adicionar. Isso garantirá que o cliente do Helm esteja atualizado:

      Para verificar o acesso ao repo stable, execute uma pesquisa nos gráficos:

      Isso dará a você a lista de gráficos disponíveis, semelhante a esta:

      Output

      NAME CHART VERSION APP VERSION DESCRIPTION stable/acs-engine-autoscaler 2.2.2 2.1.1 DEPRECATED Scales worker nodes within agent pools stable/aerospike 0.3.2 v4.5.0.5 A Helm chart for Aerospike in Kubernetes stable/airflow 5.2.4 1.10.4 Airflow is a platform to programmatically autho... stable/ambassador 5.3.0 0.86.1 A Helm chart for Datawire Ambassador ...

      Esse resultado significa que seu cliente do Helm está em execução e atualizado.

      Agora que o Helm está configurado, instale o gráfico do Helm nfs-server-provisioner para configurar o servidor NFS. Caso queira examinar o conteúdo do gráfico, consulte sua documentação no GitHub.

      Quando implantar o gráfico do Helm, você vai definir algumas variáveis para seu servidor NFS para especificar ainda mais a configuração do seu aplicativo. Você também pode investigar outras opções de configuração e ajustá-las para se adequarem às necessidades do aplicativo.

      Para instalar o gráfico do Helm, use o seguinte comando:

      • helm install nfs-server stable/nfs-server-provisioner --set persistence.enabled=true,persistence.storageClass=do-block-storage,persistence.size=200Gi

      Esse comando provisiona o servidor NFS com as seguintes opções de configuração:

      • Adiciona um volume persistente ao servidor NFS com o sinalizador --set. Isso garante que todos os dados do NFS compartilhados permaneçam nas reinicializações do pod.
      • Para o armazenamento persistente, usa a classe de armazenamento do-block-storage.
      • Provisiona um total de 200 Gi para que o servidor NFS consiga dividir em exportações.

      Nota: a opção persistence.size determinará a capacidade total de todos os volumes NFS que você pode provisionar. No momento em que este artigo foi publicado, apenas a versão 1.16.2-do.3 e posteriores do DOKS ofereciam suporte à expansão de volumes. Dessa maneira, se você estiver usando uma versão mais antiga do DOKS, o redimensionamento desse volume terá que ser feito manualmente. Caso seja esse o caso, certifique-se de definir esse tamanho levando em conta suas necessidades futuras.

      Depois que esse comando terminar, você receberá um resultado semelhante ao seguinte:

      Output

      NAME: nfs-server LAST DEPLOYED: Thu Feb 13 19:30:07 2020 NAMESPACE: default STATUS: deployed REVISION: 1 TEST SUITE: None NOTES: The NFS Provisioner service has now been installed. A storage class named 'nfs' has now been created and is available to provision dynamic volumes. You can use this storageclass by creating a PersistentVolumeClaim with the correct storageClassName attribute. For example: --- kind: PersistentVolumeClaim apiVersion: v1 metadata: name: test-dynamic-volume-claim spec: storageClassName: "nfs" accessModes: - ReadWriteOnce resources: requests: storage: 100Mi

      Para ver o servidor NFS que você provisionou, execute o seguinte comando:

      Isso mostrará o seguinte:

      Output

      NAME READY STATUS RESTARTS AGE nfs-server-nfs-server-provisioner-0 1/1 Running 0 11m

      Em seguida, verifique a storageclass que você criou:

      Isso dará um resultado parecido com este:

      Output

      NAME PROVISIONER AGE do-block-storage (default) dobs.csi.digitalocean.com 90m nfs cluster.local/nfs-server-nfs-server-provisioner 3m

      Agora, você tem um servidor NFS em execução, bem como uma storageclass que pode usar para o provisionamento dinâmico de volumes. Em seguida, você poderá criar uma implantação que usará esse armazenamento, compartilhando-a em múltiplas instâncias.

      Passo 2 — Implantando um aplicativo usando um PersistentVolumeClaim compartilhado

      Neste passo, você criará uma implantação de exemplo no seu cluster DOKS para testar sua configuração de armazenamento. A implantação será a de um app de servidor Web Nginx chamado web.

      Para implantar esse aplicativo, primeiro grave o arquivo YAML para especificar a implantação. Abra um arquivo nginx-test.yaml com seu editor de texto; este tutorial usará o nano:

      Neste arquivo, adicione as linhas a seguir para definir a implantação com um PersistentVolumeClaim chamado nfs-data:

      nginx-test.yaml

      apiVersion: apps/v1
      kind: Deployment
      metadata:
        labels:
          app: web
        name: web
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: web
        strategy: {}
        template:
          metadata:
            creationTimestamp: null
            labels:
              app: web
          spec:
            containers:
            - image: nginx:latest
              name: nginx
              resources: {}
              volumeMounts:
              - mountPath: /data
                name: data
            volumes:
            - name: data
              persistentVolumeClaim:
                claimName: nfs-data
      ---
      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: nfs-data
      spec:
        accessModes:
        - ReadWriteMany
        resources:
          requests:
            storage: 2Gi
        storageClassName: nfs
      

      Salve o arquivo e saia do editor de texto.

      Essa implantação (web) foi configurada para usar o nfs-data do PersistentVolumeClaim (PVC) que a acompanha e para montá-la em /data.

      Na definição do PVC, você descobrirá que o storageClassName está definido como nfs. Isso diz ao cluster para atender esse armazenamento, usando as regras de storageClass nfs que você criou no passo anterior. O novo PersistentVolumeClaim será processado e, em seguida, um compartilhamento NFS será provisionado para atender à solicitação e à declaração, na forma de um Volume Persistente. O pod tentará montar aquele PVC assim que ele tiver sido provisionado. Assim que terminar a montagem, você verificará a funcionalidade ReadWriteMany (RMX).

      Execute a implantação com o seguinte comando:

      • kubectl apply -f nginx-test.yaml

      Isso dará o seguinte resultado:

      Output

      deployment.apps/web created persistentvolumeclaim/nfs-data created

      Em seguida, verifique e veja o pod web em funcionamento:

      Isso irá mostrar o seguinte:

      Output

      NAME READY STATUS RESTARTS AGE nfs-server-nfs-server-provisioner-0 1/1 Running 0 23m web-64965fc79f-b5v7w 1/1 Running 0 4m

      Agora que a implantação de exemplo está em funcionamento, você pode dimensioná-la para três instâncias, usando o comando kubectl scale:

      • kubectl scale deployment web --replicas=3

      Isso dará o resultado:

      Output

      deployment.extensions/web scaled

      Agora, execute o kubectl get novamente:

      Você encontrará as instâncias dimensionadas da implantação:

      Output

      NAME READY STATUS RESTARTS AGE nfs-server-nfs-server-provisioner-0 1/1 Running 0 24m web-64965fc79f-q9626 1/1 Running 0 5m web-64965fc79f-qgd2w 1/1 Running 0 17s web-64965fc79f-wcjxv 1/1 Running 0 17s

      Agora, você tem três instâncias da sua implantação do Nginx, conectadas ao mesmo Volume Persistente. No próximo passo, você irá garantir que elas possam compartilhar dados entre si.

      Passo 3 — Validando o compartilhamento de dados do NFS

      No passo final, você validará a configuração para que os dados sejam compartilhados por todas as instâncias que foram montadas para o compartilhamento do NFS. Para fazer isso, criará um arquivo no diretório /data em um dos pods e, em seguida, verificará se o arquivo existe no diretório /data de outro pod.

      Para validar isso, você usará o comando kubectl exec. Esse comando permite que você especifique um pod e execute um comando dentro daquele pod. Para aprender mais sobre a inspeção de recursos usando o kubectl, veja nossa Folha de referências do kubectl.

      Para criar um arquivo chamado hello_world dentro de um dos seus pods web, use o kubectl exec para repassar o comando touch. Note que o número após web – no nome do pod – será diferente para você. Assim, certifique-se de substituir o nome do pod destacado por um dos pods que você apurou no resultado do comando kubectl get pods, no último passo.

      • kubectl exec web-64965fc79f-q9626 -- touch /data/hello_world

      Em seguida, altere o nome do pod e use o comando ls para listar os arquivos no diretório /data de um outro pod:

      • kubectl exec web-64965fc79f-qgd2w -- ls /data

      Seu resultado mostrará o arquivo que criou no primeiro pod:

      Output

      hello_world

      Isso mostra que todos os pods compartilham dados usando o NFS e que sua configuração está funcionando corretamente.

      Conclusão

      Neste tutorial, você criou um servidor NFS com apoio do armazenamento em bloco da DigitalOcean. Depois, o servidor NFS usou aquele armazenamento em bloco para provisionar e exportar os compartilhamentos NFS para as cargas de trabalho em um protocolo compatível com RWX. Ao fazer isso, você conseguiu contornar uma limitação técnica do armazenamento em bloco da DigitalOcean e compartilhar os mesmos dados do PVC em muitos pods. Por seguir este tutorial, agora o seu cluster DOKS está configurado para acomodar um conjunto muito mais amplo de casos de uso de implantação.

      Caso queira aprender mais sobre o Kubernetes, confira nosso Currículo de Kubernetes para desenvolvedores full-stack, ou examine a documentação de produto do Kubernetes da DigitalOcean.



      Source link