Implantação de aplicativos do Django no Kubernetes
Por ser uma plataforma de código aberto de orquestração de containers que automatiza a implantação, o escalamento e o balanceamento de carga, o Kubernetes oferece resiliência e flexibilidade sem igual no gerenciamento dos seus aplicativos do Django.
Quer você esteja iniciando um projeto de pequena escala ou gerenciando uma aplicação complexa, o Kubernetes fornece um ambiente robusto para incrementar o seu aplicativo do Django, garantindo que ele esteja pronto para atender às demandas do desenvolvimento moderno para a Web.
Ao automatizar a implantação, o escalamento e a operação de aplicativos em containers, o Kubernetes (ou K8s) oferece inúmeros benefícios para as organizações no ritmo acelerado do setor de tecnologia.
Não importa se você é um desenvolvedor em Django buscando aumentar as suas habilidades de implantação ou um entusiasta do Kubernetes pronto para explorar a integração com o Django: este guia tem algo para todos.
A introdução deste tutorial explora a relação simbiótica entre o Django e o Kubernetes, permitindo que você coloque a sua aplicação Web em containers de forma transparente, distribua cargas de trabalho entre clusters e garanta alta disponibilidade.
Django
O Django é um framework de alto nível para a Web em Python que é um modelo de eficiência e simplicidade no mundo do desenvolvimento para a Web. O Django nasceu da necessidade de criar aplicativos Web que fossem rápidos, robustos e fáceis de manter, e tornou-se a primeira escolha de desenvolvedores e organizações.
Em sua essência, o Django adota a filosofia de “pilhas incluídas” e oferece uma grande variedade de ferramentas, bibliotecas e convenções incorporadas, que facilitam o processo de desenvolvimento. Ele simplifica tarefas complexas, como roteamento de URLs, integração com bancos de dados e autenticação de usuários, permitindo que os desenvolvedores se concentrem em criar seus aplicativos.
Um dos benefícios mais importantes do Django é o fato de ele seguir o princípio “não se repita” (“Don’t repeat yourself”, DRY), reduzindo a redundância e tornando o código mais fácil de manter. Ele também segue o padrão de arquitetura “modelo-visualização-controlador” (MVC), tornando os aplicativos mais estruturados e fáceis de gerenciar.
O Django também dá prioridade à segurança, o que o torna menos sujeito a vulnerabilidades comuns na Web. Ele já inclui recursos como a proteção contra “cross-site scripting” (XSS) e “cross-site request forgery” (CSRF) desde a instalação. O Django oferece uma combinação poderosa de rapidez, simplicidade e segurança, e é a escolha ideal para desenvolvedores que busquem criar aplicativos robustos e cheios de recursos para a Web, com o mínimo de esforço.
Orquestradores de containers
Os orquestradores de containers são ferramentas essenciais para gerenciar e automatizar a implantação, escalamento e operações de aplicativos em containers. Há vários orquestradores de containers disponíveis no mercado. Alguns dos mais populares são:
1. Kubernetes, a principal plataforma de orquestração de containers, oferece um ambiente robusto e adaptável para lidar com aplicativos em containers. Ele automatiza tarefas como o escalamento, o balanceamento de cargas e as verificações de saúde dos containers e tem um amplo ecossistema de extensões.
2. Docker Swarm é uma solução de orquestração de containers oferecida pela Docker. Ele foi projetado para ser simples de configurar e usar, e é uma boa escolha para aplicações menores ou organizações que já usam o Docker, pois ele usa a mesma interface de linha de comando e a mesma API que o Docker.
3. OpenShift é uma plataforma corporativa de Kubernetes desenvolvida pela Red Hat. Ele adiciona ao Kubernetes ferramentas operacionais e de desenvolvedor, simplificando a implantação e o gerenciamento de aplicativos em containers.
4. Nomad, desenvolvido pela HashiCorp, é um orquestrador leve e amigável ao usuário, capaz de gerenciar aplicativos com e sem containers.
5. Apache Mesos é um kernel distribuído de sistema, de código aberto. Já o DC/OS (Data Center Operating System) é uma plataforma de nível corporativo criada sobre o Mesos. O DC/OS amplia o alcance do Mesos com recursos adicionais para gerenciar e escalar aplicativos em containers.
As equipes de software trabalham primariamente com plataformas gerenciadas oferecidas por provedores conhecidos de nuvem, como AWS, Google Cloud Platform e Azure. Esses provedores oferecem serviços como Amazon EKS, Google GKE e Azure AKS, todos eles soluções gerenciadas de Kubernetes. Esses serviços simplificam a configuração, expansão e administração de clusters de Kubernetes e integram-se de forma transparente com seus respectivos ambientes de nuvem, garantindo eficiência na orquestração de containers e na implantação de aplicativos.
Como criar um aplicativo do Django no PyCharm
Neste tutorial, vamos começar gerando um aplicativo mínimo do Django. Depois, vamos colocá-lo em um container e, na etapa final, implantá-lo em um cluster local de Kubernetes usando o Docker Desktop.
Se você for novato em trabalhar com o framework Django, mas estiver ansioso para criar um aplicativo do zero com ele, leia esta postagem de blog.
Você pode acessar aqui o código-fonte usado neste tutorial.
Vamos começar criando um novo aplicativo do Django no PyCharm.
Para criar o seu projeto, abra o PyCharm e clique em New Project. Se o PyCharm já estiver em execução, selecione File | New Project no menu principal.
Forneça os dados essenciais, como o nome do projeto, o local e o tipo de interpretador, usando o venv ou um ambiente personalizado.
Em seguida, clique em Create.
O PyCharm fará o trabalho pesado, configurando o seu projeto e criando o ambiente virtual.
Gunicorn
Depois de criar o projeto, instale o Gunicorn, um servidor de HTTP em Python para interfaces de gateways de servidores Web (WSGI). O Gunicorn é um servidor-modelo de trabalho para a Web, usado com aplicativos de Web em Python antes do fork, e costuma ser usado em combinação com frameworks de Web como o Django, o Flask e outros, para implantar aplicativos de Web e disponibilizá-los na Internet.
A janela de ferramentas Python Packages é a maneira mais rápida e fácil de pré-visualizar e instalar pacotes para o interpretador Python selecionado no momento.
Você pode abrir essa janela de ferramentas acionando View | Tool Windows | Python Packages.
Psycopg 2
O Psycopg 2 é uma biblioteca do Python usada para se conectar a bancos de dados PostgreSQL e interagir com eles. Ele fornece uma interface no Python para trabalhar com o PostgreSQL, um dos mais populares sistemas de código aberto para o gerenciamento de bancos de dados relacionais. O Psycopg 2 permite que os desenvolvedores Python executem diversas operações de banco de dados, como incluir, atualizar e recuperar dados, além de executar consultas em SQL e gerenciar conexões a bancos de dados dentro de programas em Python.
Antes de instalar o psycopg2, você precisa instalar as dependências em nível de sistema, usando brew install libpq no macOS ou apt-get install libpq-dev no Linux.
Referência: postgresql.org/docs/16/libpq.html
O libpq é a biblioteca de cliente do PostgreSQL. É uma biblioteca em C que fornece os recursos necessários para os aplicativos-clientes se conectarem a servidores de bancos de dados PostgreSQL, interagirem com eles e gerenciá-los.
Depois de terminar as modificações específicas, atualize a seção de settings.py referente a DATABASES.
Nunca deixe de passar as suas credenciais secretas através de variáveis de ambiente.
STATIC_ROOT
No Django, STATIC_ROOT é uma configuração usada para especificar o caminho absoluto no sistema de arquivos onde os arquivos estáticos coletados serão armazenados quando você executar o comando de gerenciamento collectstatic. Tipicamente, os arquivos estáticos incluem recursos de CSS, JavaScript, imagens e outros usados pelo seu aplicativo de Web. A configuração STATIC_ROOT é essencial para os servidores fornecerem arquivos estáticos em um ambiente de produção.
Defina uma variável de ambiente para STATIC_ROOT na linha 127. Essa variável apontará para um caminho de arquivo, que por sua vez levará a um volume persistente do Kubernetes. Explicarei mais tarde como fazer essa configuração.
Para coletar arquivos estáticos, execute este comando:
python manage.py collectstatic
Este comando reunirá os arquivos estáticos e os colocará no diretório especificado em STATIC_ROOT. Então, você poderá fornecer esses recursos diretamente, através de um servidor de Web NGINX ou Apache — uma abordagem mais eficiente para ambientes de produção.
Dockerfile
Um Dockerfile é um documento simples de texto que contém diretivas para construir imagens do Docker.
1. FROM python:3.11: Esta linha especifica a imagem de base da imagem do Docker, usando a imagem oficial do Python 3.11 do Docker Hub. Será feito o build do aplicativo e ele será executado sobre essa imagem de base, que já tem o Python pré-instalado.
2. ENV PYTHONUNBUFFERED 1: Esta linha atribui o valor 1 à variável de ambiente PYTHONUNBUFFERED. Costuma-se recomendar definir esta variável de ambiente ao executar o Python em containers do Docker, para garantir que o Python não coloque a saída em um buffer. Isso ajuda a obter logs e informações de depuração do aplicativo em tempo real.
3. WORKDIR /app: Esta linha define /app como o diretório de trabalho no container do Docker. Todos os comandos subsequentes serão executados nesse diretório.
4. COPY . /app: Esta linha copia o conteúdo do diretório atual (aquele onde está localizado o Dockerfile) para o diretório /app dentro do container. Isso inclui o código do seu aplicativo e quaisquer arquivos necessários à imagem do Docker.
5. RUN pip install -r requirements.txt: Esta linha executa o comando pip install, para instalar as dependências do Python listadas no arquivo requirements.txt, localizado no diretório /app. Esta é uma prática comum para aplicativos em Python, pois ela permite a você gerenciar as dependências do aplicativo.
6. EXPOSE 8000: Informa ao Docker que o container estará escutando a porta 8000. Esta linha não publica de fato a porta. É uma declaração de metadado para indicar quais portas o container poderá usar.
7. CMD ["gunicorn", "django_kubernetes_tutorial.wsgi:application", "--bind", "0.0.0.0:8000"]: Esta linha especifica o comando-padrão a ser executado na inicialização do container. Esse comando usa o Gunicorn como servidor para o aplicativo do Django e especifica que o Gunicorn deverá escutar todas as interfaces de rede (0.0.0.0) na porta 8000, usando o aplicativo do WSGI definido em django_kubernetes_tutorial.wsgi:application.
DockerHub
Visite hub.docker.com e faça login ou crie uma conta na plataforma.
Clique em Create repository.
Em seguida, informe o nome do repositório e defina a visibilidade como pública. Se você estiver trabalhando com dados sensíveis ou confidenciais, defina a visibilidade como Private.
Depois de criar o repositório, você precisará fazer o build da imagem do Docker e depois fazer o push da imagem para o registro.
Antes de executar o comando, certifique-se de que o seu arquivo requirements.txt esteja atualizado, executando o seguinte comando:
pip freeze > requirements.txt
Para construir uma imagem, execute o comando a seguir:
docker build -t mukulmantosh/django-kubernetes:1.0 .
docker build -t /django-kubernetes:1.0 .
Este comando variará em função das suas circunstâncias específicas e você precisará usar o seu nome pessoal de usuário.
Agora, você precisa se autenticar no Docker Hub para fazer o push da imagem para o registro.
Digite este comando no terminal:
docker login
Digite o seu nome de usuário e senha. Depois de ter se autenticado com sucesso, você poderá fazer o push da imagem, executando este comando:
docker push mukulmantosh/django-kubernetes:1.0
docker push /django-kubernetes:1.0
Depois de o push da imagem ter sido concluído com sucesso, você poderá observar as alterações no Docker Hub.
Se você não estiver planejando fazer push de mais nenhuma imagem para o registro, poderá encerrar a sessão, executando este comando:
docker logout
Se você quiser fazer um pull local dessa imagem, visite hub.docker.com/r/mukulmantosh/django-kubernetes.
Configuração do Kubernetes: como criar arquivos em YAML
Esta seção do tutorial descreve a implantação de aplicativos em clusters locais do Kubernetes.
Neste tutorial, usaremos o Docker Desktop, mas você também pode usar o minikube ou o kind.
Namespaces
No Kubernetes, namespaces é uma partição virtual dentro de um cluster, usada para agrupar e isolar recursos e objetos. É uma maneira de criar diversos clusters virtuais dentro de um único cluster físico.
Você pode criar e gerenciar namespaces usando o kubectl, a ferramenta de linha de comando do Kubernetes, ou definindo-os em manifestos em YAML ao implantar recursos.
- Se você tiver escolhido o Docker Desktop como a sua plataforma de preferência para executar o Kubernetes, não se esqueça de habilitar o Kubernetes nas configurações, clicando na caixa de opção Enable Kubernetes.
Execute o comando a seguir no terminal para criar o namespace:
kubectl create ns django-app
Como implementar bancos de dados com o K8s
Para começar, vamos estabelecer uma instância do PostgreSQL no nosso cluster do Kubernetes no ambiente local.
PersistentVolume
No Kubernetes, um volume persistente (PV) é um espaço de armazenamento provisionado no cluster por um administrador. Ao armazenarem dados de forma independente do ciclo de vida de um pod, os PVs permitem que o gerenciamento e a abstração dos recursos de armazenamento sejam mais dissociados e flexíveis. Isso significa que os dados podem persistir mesmo que o pod que os utiliza seja excluído ou reatribuído a um nó diferente no cluster.
Vamos criar um volume persistente e chamá-lo de pv.yml.
Esta configuração em YAML define um recurso do tipo PersistentVolume, com o nome de postgres-pv e uma capacidade de 1 gigabyte, montado com o modo de acesso ReadWriteOnce e acessado por um caminho local no sistema de arquivos do nó, localizado em /data/db. Este PV pode ser usado para fornecer armazenamento persistente a pods que precisem de acesso a um diretório no sistema de arquivos do nó. Ele é adequado para aplicações como o PostgreSQL ou outros serviços dinâmicos que precisem de armazenamento persistente.
Para produção, recomendamos usar o StatefulSets do Kubernetes ou soluções de nuvem como o AWS RDS ou o Google CloudSQL.
PersistentVolumeClaim
No Kubernetes, um PersistentVolumeClaim (PVC) é um objeto de recurso usado por um pod para requisitar a um PV uma quantidade específica de armazenamento com certas propriedades. Os PVCs são uma maneira de os aplicativos requisitarem recursos de armazenamento sem precisarem saber os detalhes da infraestrutura subjacente.
Ao criar e usar PVCs, o Kubernetes fornece uma maneira de alocar e gerenciar dinamicamente recursos de armazenamento para os aplicativos, enquanto abstrai a infraestrutura subjacente de armazenamento, facilitando trabalhar com aplicativos dinâmicos e gerenciá-los em ambientes com containers.
Vamos criar um PVC e chamá-lo de pvc.yml.
Um PVC solicita recursos de armazenamento e é vinculado a um PV, que por sua vez fornece o armazenamento real.
Esta configuração em YAML define um PersistentVolumeClaim com o nome de postgres-pvc, dentro do namespace django-app. Esse PVC requisita um gigabyte de armazenamento, com o modo de acesso ReadWriteOnce, e especifica explicitamente a StorageClass manual. Este PVC deverá ser vinculado a um PV já existente, com o nome de postgres-pv. Na prática, estará reservando esse volume para ser usado por pods que referenciem esse PVC dentro do namespace django-app.
ConfigMap
No Kubernetes, um ConfigMap é um objeto de API usado para armazenar dados de configurações em pares de chaves e valores. ConfigMaps são uma maneira de dissociar os dados de configurações do código do aplicativo, facilitando gerenciar e atualizar configurações sem modificar ou reimplantar containers. Eles são especialmente úteis para configurar aplicativos, microsserviços e outros componentes dentro de um cluster do Kubernetes.
Vamos criar um ConfigMap e chamá-lo de cm.yml.
Por razões de segurança, embora este tutorial use ConfigMaps, recomenda-se armazenar credenciais sensíveis no Secrets do Kubernetes ou explorar alternativas como o Bitnami Sealed Secrets, a AWS Parameter Store ou o HashiCorp Vault.
Deployment (implantação)
No Kubernetes, um Deployment (implantação) é um objeto de recurso usado para gerenciar a implantação e o escalamento de aplicativos. Faz parte do grupo da API do Kubernetes e é uma maneira declarativa de definir e gerenciar o estado desejado do seu aplicativo.
Um Deployment é um recurso de nível superior do Kubernetes, usado para gerenciar e escalar pods de aplicativos.
Esta configuração em YAML define um Deployment com o nome de postgres no namespace django-app. Ela implanta uma única réplica de um banco de dados PostgreSQL (versão 16.0) com armazenamento persistente. O pod do banco de dados é rotulado como app: postgresdb e o armazenamento é fornecido por um PVC com o nome de postgres-pvc. A configuração e as credenciais do container do PostgreSQL são fornecidas através de um ConfigMap com o nome de db-secret-credentials.
Serviço
No Kubernetes, um serviço é um objeto de recurso usado para expor um conjunto de pods como um serviço de rede. Os Services permitem a comunicação pela rede entre diferentes partes do seu aplicativo em execução em um cluster do Kubernetes. Eles fornecem um endpoint estável para os clientes acessarem essas partes. Os Services abstraem a infraestrutura de rede subjacente, facilitando conectar e descobrir os componentes do seu aplicativo.
Esta configuração em YAML define um Service NodePort com o nome de postgres-service, dentro do namespace django-app. Ela expõe o serviço do PostgreSQL em execução em pods rotulados como “app: postgresdb“, na porta 5432 dentro do cluster. Clientes externos podem acessar o Service no endereço IP de qualquer nó, usando a porta 30004. Este Service disponibiliza uma maneira de tornar o banco de dados PostgreSQL acessível de fora do cluster do Kubernetes.
Como criar configurações em YAML para um aplicativo do Django
PersistentVolume
Este código em YAML define um PersistentVolume com o nome de staticfiles-pv e uma capacidade de armazenamento de 1 GB, permitindo que vários pods leiam e gravem nele ao mesmo tempo. O armazenamento é fornecido por um caminho no host local, situado em /data/static. Os arquivos estáticos do Django serão armazenados nesse local.
PersistentVolumeClaim
Este código em YAML define um PVC com o nome de staticfiles-pvc, no namespace django-app. Ele requisita armazenamento a um PV com a StorageClass “manual”, com uma capacidade de pelo menos 1 GB, e especifica que precisa do nível de acesso ReadWriteMany. A requisição é explicitamente vinculada a um PV já existente, chamado staticfiles-pv, para atender às suas necessidades de armazenamento. Isso permite que os pods no namespace django-app usem este PVC para acessar e usar o armazenamento fornecido pelo PV associado.
ConfigMap
Este código em YAML define um ConfigMap com o nome de app-cm no namespace django-app. Esse ConfigMap contém diversos pares de chaves e valores, que armazenam dados de configuração. Ele pode ser usado por pods ou outros recursos dentro do namespace django-app para acessar parâmetros de configuração, como dados de conexões a bancos de dados e caminhos para arquivos estáticos.
Deployment (implantação)
Este código em YAML define um Deployment com o nome de django-app-deploy, no namespace django-app. Ela cria uma réplica (pod) que executa um container com uma imagem e uma configuração específicas do Docker. Esse pod está associado a dois volumes, postgres-db-storage e staticfiles, fornecidos por PVCs. O container está configurado para usar as variáveis de ambiente de um ConfigMap com o nome de app-cm e escutar a porta 8000. Os volumes são montados em caminhos específicos dentro do container, para darem acesso ao armazenamento do banco de dados e a arquivos estáticos. Este Deployment é uma maneira comum de executar um aplicativo do Django usando o Kubernetes.
Se você estiver interessado em fazer pull de imagens de um registro privativo, leia isto.
Service (serviço)
O Service escuta a porta 8000 e direciona o tráfego de entrada para pods rotulados como app: django-application. Esta é uma configuração comum para expor e balancear a carga de aplicativos Web em um cluster de Kubernetes no qual estejam sendo executadas diversas instâncias de um mesmo aplicativo. O Service garante uma distribuição uniforme do tráfego entre essas instâncias.
NGINX
O NGINX é um servidor de Web e de proxy reversa de alto desempenho, conhecido por sua rapidez, confiabilidade e escalabilidade. Ele cuida de forma eficiente do tráfego de Web, do balanceamento de carga e da entrega de conteúdo, o que o torna uma escolha popular em servidores de Web e de aplicativos.
ConfigMap
Este código em YAML define um ConfigMap do Kubernetes com o nome de nginx-cm no namespace django-app. Esse ConfigMap contém um par de chave e valor no qual a chave é default.conf e o valor é um arquivo de configuração do NGINX com diversas linhas que faz proxy da solicitação para o servidor de back-end.
Deployment (implantação)
Este código em YAML define um Deployment que cria e gerencia pods que executam um container do NGINX com volumes e configurações específicos. Esse Deployment garante que sempre esteja sendo executada uma réplica de cada pod no namespace django-app. Ela também substitui a configuração-padrão do NGINX pelo ConfigMap nginx-cm.
Service (serviço)
Esta configuração em YAML cria um Service do Kubernetes com o nome de nginx-service no namespace django-app. Ela expõe pods com o rótulo app:nginx na porta 80 dentro do cluster e também torna o serviço acessível na NodePort 30005 em cada nó do cluster. Isso permite que o tráfego externo chegue aos pods que estão executando o aplicativo do NGINX, através do serviço NodePort.
Como gerenciar cargas de trabalho em lote através de jobs do Kubernetes
No Kubernetes, um Job é um objeto de recurso que representa uma única unidade de trabalho ou uma tarefa finita. Os Jobs são projetados para executarem tarefas até o final, com um número especificado de execuções terminadas com sucesso.
Migração de bancos de dados
Esta configuração em YAML define um Job do Kubernetes com o nome de django-db-migrations, no namespace django-app. Esse Job executa um container usando uma imagem do Docker especial para migrações do Django e monta um PVC para fornecer o armazenamento para os arquivos relacionados ao banco de dados. Se o Job falhar, ele poderá ser tentado novamente até 15 vezes e reterá seu pod por 100 segundos depois de terminar. O Job criará novas tabelas no PostgreSQL.
Arquivos estáticos
Esta configuração em YAML define um Job do Kubernetes com o nome de django-staticfiles, no namespace django-app. Esse Job executa um container usando uma imagem do Docker especial para coletar arquivos estáticos para um aplicativo do Django e monta um PVC para fornecer o armazenamento para os arquivos estáticos. Se o Job falhar, ele poderá ser tentado novamente até três vezes e reterá seu pod por 100 segundos depois de terminar, para fins de depuração. O Job copiará os arquivos estáticos para o caminho de montagem (mountPath), que é /data/static.
Para iniciar o aplicativo
Para iniciar o aplicativo, navegue até o diretório k8s e execute o comando a seguir:
Depois de implantar o aplicativo, use o comando a seguir para verificar o status dos pods em execução:
kubectl get pods -n django-app -w
Como criar um superusuário no Django
Depois que todos os seus aplicativos estiverem sendo executados normalmente, crie um superusuário para fazer login como administrador no Django.
Execute este comando para obter a lista dos pods em execução:
kubectl get pods -n django-app
Para entrar no shell do container, execute:
kubectl exec -it -n django-app -- sh
Em seguida, execute:
python manage.py createsuperuser
Depois de criar o superusuário com sucesso, abra http://127.0.0.1:30005 em um navegador. Você será direcionado à página-padrão de boas-vindas.
Depois, vá até a administração do Django, em http://127.0.0.1:30005/admin.
Digite o nome de usuário e a senha que você acabou de criar.
Depois de autenticado, você será redirecionado à página de administração do Django.
Se você tentar fazer login através de localhost:30005/admin, talvez receba um erro 403 Forbidden (CSRF).
Você pode resolver isso no arquivo settings.py, sob CSRF_TRUSTED_ORIGINS.
CSRF_TRUSTED_ORIGINS é uma configuração no Django usada para especificar uma lista de origens confiáveis para proteção contra “cross-site request forgery” (CSRF). CSRF é uma vulnerabilidade de segurança que pode ocorrer quando quem faz um ataque engana um usuário e o faz enviar sem saber uma solicitação indesejada a um aplicativo Web. Para evitar isso, o Django incorpora uma proteção contra CSRF.
CSRF_TRUSTED_ORIGINS permite que você defina uma lista de origens (Web sites) a partir das quais serão aceitas solicitações com proteção contra CSRF. Qualquer solicitação proveniente de uma origem não incluída nessa lista será considerada potencialmente maliciosa e devidamente bloqueada.
Esta configuração pode ser usada para permitir certas solicitações de outras origens ao seu aplicativo do Django, sem deixar de manter a segurança contra ataques de CSRF. Ela é especialmente útil em situações nas quais o seu aplicativo precise interagir com outros serviços ou APIs de Web hospedados em domínios diferentes.
Se você estiver usando ferramentas de interface gráfica como o Kubernetes Dashboard, poderá visualizar facilmente os seus pods em execução, implantações, volumes persistentes, etc.
Suporte ao Kubernetes no PyCharm
O PyCharm oferece um editor incrementado e suporte de runtime sob medida para o Kubernetes, trazendo inúmeros recursos para simplificar o seu gerenciamento do Kubernetes. Esses recursos incluem:
- Navegar pelos objetos do cluster, extraindo, editando suas configurações e descrevendo-os.
- Visualizar eventos.
- Visualizar e baixar logs de pods.
- Anexar o console de pods.
- Executar o shell em pods.
- Encaminhar portas para um pod.
- Aplicar configurações de recursos em YAML a partir do editor.
- Excluir recursos do cluster.
- Completar registros ConfigMap e Secret a partir do cluster.
- Configurar os caminhos para
kubectl. - Configurar arquivos
kubeconfigpersonalizados, globalmente ou por projeto. - Alternar entre contextos e namespaces.
- Usar o esquema de API do cluster ativo (incluindo a CRD) para editar manifestos de recursos.
Assista a este vídeo para saber mais sobre como trabalhar com o Kubernetes no PyCharm Professional.
Experimente o PyCharm gratuitamente para as suas tarefas do Kubernetes!
Referências
Já tem uma sólida compreensão do Kubernetes? Então, passe para a próxima etapa da sua jornada pela programação, explorando soluções de nuvem. Confira nossos tutoriais sobre o AWS EKS e o Google Kubernetes Engine.
Artigo original em inglês por:
Subscribe to PyCharm Blog updates
