Como executar o Django no Google Kubernetes Engine

Os aplicativos do Django executados no GKE são escalonados dinamicamente de acordo com o tráfego.

Neste tutorial, presume-se que você esteja familiarizado com o desenvolvimento de Web com o Django. Se você é novo no desenvolvimento do Django, é recomendável escrever seu primeiro aplicativo Django antes de continuar.

Embora este tutorial demonstre especificamente o Django, é possível usar esse processo de implantação com outros frameworks baseados em Django, como Wagtail e Django CMS.

Este tutorial usa o Django 3, que requer pelo menos o Python 3.7.

Também é necessário ter o Docker instalado (em inglês).

Objetivos

Com este tutorial, você vai:

  • Crie e conecte um banco de dados do Cloud SQL.
  • Crie e use valores de secret do Kubernetes.
  • Implante um app Django no Google Kubernetes Engine.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative as APIs Cloud SQL, GKE and Compute Engine.

    Ative as APIs

  5. Instale e inicialize o SDK do Cloud..

Preparar o ambiente

Clonar um aplicativo de exemplo

O código para o aplicativo de amostra do Django está no repositório GoogleCloudPlatform/python-docs-samples (em inglês) no GitHub.

  1. É possível fazer o download da amostra como um arquivo ZIP e extraí-lo ou clonar o repositório na máquina local:

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
    
  2. Acesse o diretório que contém o código de amostra:

    Linux/MacOS

    cd python-docs-samples/kubernetes_engine/django_tutorial
    

    Windows

    cd python-docs-samples\kubernetes_engine\django_tutorial
    

Confirmar a configuração do Python

Este tutorial depende do Python para executar o aplicativo de amostra na máquina. O exemplo de código também requer a instalação de dependências

Para mais detalhes, consulte o guia do ambiente de desenvolvimento em Python.

  1. Confirme se o Python contém a versão 3.7 ou posterior.

     python -V
    

    Você verá Python 3.7.3 ou mais.

  2. Crie um ambiente virtual do Python e instale as dependências:

    Linux/macOS

    python -m venv venv
    source venv/bin/activate
    pip install --upgrade pip
    pip install -r requirements.txt
    

    Windows

    python -m venv env
    venv\scripts\activate
    pip install --upgrade pip
    pip install -r requirements.txt
    

Faça o download do proxy do Cloud SQL Auth para se conectar ao Cloud SQL na sua máquina local

Quando implantado, o aplicativo usa o proxy de autenticação do Cloud SQL integrado ao ambiente do Google Kubernetes Engine para se comunicar com a instância do Cloud SQL. No entanto, para testar o aplicativo no local, é necessário instalar e usar uma cópia local do proxy no ambiente de desenvolvimento. Para mais detalhes, consulte o Guia de proxy do Cloud SQL Auth.

O proxy do Cloud SQL Auth usa a API Cloud SQL para interagir com sua instância do SQL. Para isso, é necessária autenticação de aplicativo por meio do gcloud.

  1. Autentique e receba as credenciais da API:

    gcloud auth application-default login
    
  2. Faça o download e instale o proxy do Cloud SQL Auth na sua máquina local.

    Linux de 64 bits

    1. Faça o download do proxy do Cloud SQL Auth:
      wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.amd64 -O cloud_sql_proxy
      
    2. Torne o proxy do Cloud SQL Auth executável:
      chmod +x cloud_sql_proxy
      

    Linux de 32 bits

    1. Faça o download do proxy do Cloud SQL Auth:
      wget https://dl.google.com/cloudsql/cloud_sql_proxy.linux.386 -O cloud_sql_proxy
      
    2. Se o comando wget não for encontrado, execute sudo apt-get install wget abd repita o comando de download.
    3. Torne o proxy do Cloud SQL Auth executável:
      chmod +x cloud_sql_proxy
      

    macOS de 64 bits

    1. Faça o download do proxy do Cloud SQL Auth:
      curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.amd64
      
    2. Torne o proxy do Cloud SQL Auth executável:
      chmod +x cloud_sql_proxy
      

    macOS de 32 bits

    1. Faça o download do proxy do Cloud SQL Auth:
      curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.386
      
    2. Torne o proxy do Cloud SQL Auth executável:
      chmod +x cloud_sql_proxy
      

    Windows de 64 bits

    Clique com o botão direito do mouse em https://dl.google.com/cloudsql/cloud_sql_proxy_x64.exe e selecione Salvar link como para fazer o download do proxy do Cloud SQL Auth. Renomeie o arquivo para cloud_sql_proxy.exe.

    Windows de 32 bits

    Clique com o botão direito do mouse em https://dl.google.com/cloudsql/cloud_sql_proxy_x86.exe e selecione Salvar link como para fazer o download do proxy do Cloud SQL Auth. Renomeie o arquivo para cloud_sql_proxy.exe.

    Imagem do Docker do proxy do Cloud SQL Auth

    Por conveniência, várias imagens de contêiner que contêm o proxy do Cloud SQL Auth estão disponíveis no GitHub no repositório do proxy do Cloud SQL Auth. É possível extrair a imagem mais recente na sua máquina local usando o Docker com o seguinte comando:
    docker pull gcr.io/cloudsql-docker/gce-proxy:1.19.1
    

    Outros SOs

    Para outros sistemas operacionais não incluídos aqui, compile o proxy do Cloud SQL Auth na origem.

    Você pode optar por mover o download para um lugar comum, como um local do seu PATH ou seu diretório principal. Se você optar por fazer isso, ao iniciar o proxy do Cloud SQL Auth posteriormente no tutorial, lembre-se de consultar o local escolhido ao usar os comandos cloud_sql_proxy.

Criar serviços de apoio

Neste tutorial, usamos vários serviços do Google Cloud para fornecer o banco de dados, o armazenamento de mídia e o armazenamento secreto compatíveis com o projeto Django implantado. Esses serviços são implantados em uma região específica. Para garantir a eficiência entre os serviços, todos eles precisam ser implantados na mesma região. Para mais informações sobre a região mais próxima de você, consulte Produtos disponíveis por região.

Configurar uma instância do Cloud SQL para PostgreSQL

O Django oferece suporte oficial a vários bancos de dados relacionais, mas oferece a maior parte do suporte para o PostgreSQL. O PostgreSQL é compatível com o Cloud SQL. Portanto, este tutorial escolhe usar esse tipo de banco de dados.

A seção a seguir descreve a criação de uma instância do PostgreSQL, um banco de dados e um usuário do banco de dados para o aplicativo.

  1. Crie a instância do PostgreSQL:

    Console

    1. No Console do Cloud, acesse a página Instâncias do Cloud SQL.

      Acessar a página "Instâncias" do Cloud SQL

    2. Clique em Create Instance.

    3. Clique em PostgreSQL.

    4. No campo ID da instância, insira INSTANCE_NAME.

    5. Insira uma senha para o usuário postgres.

    6. Mantenha os valores padrão nos outros campos.

    7. Clique em Criar.

    Leva alguns minutos para criar a instância e ela deve estar pronta para uso.

    gcloud

    • Crie a instância do PostgreSQL:

      gcloud sql instances create INSTANCE_NAME \
          --project PROJECT_ID \
          --database-version POSTGRES_13 \
          --tier db-f1-micro \
          --region REGION
      

    Substitua:

    • INSTANCE_NAME: o nome da instância do Cloud SQL.
    • PROJECT_ID: o ID do projeto do Google Cloud
    • REGION: a região do Google Cloud

    Leva alguns minutos para criar a instância e ela deve estar pronta para uso.

  2. Na instância criada, crie um banco de dados:

    Console

    1. Na página da sua instância, acesse a guia Bancos de dados.
    2. Clique em Create database.
    3. Na caixa de diálogo Nome do banco de dados, insira DATABASE_NAME.
    4. Clique em Criar.

    gcloud

    • Crie o banco de dados na instância recém-criada:

      gcloud sql databases create DATABASE_NAME \
          --instance INSTANCE_NAME
      

      Substitua DATABASE_NAME por um nome para o banco de dados dentro da instância.

  3. Crie um usuário de banco de dados:

    Console

    1. Na página da sua instância, acesse a guia Usuários.
    2. Clique em Add User Account.
    3. Na caixa de diálogo Adicionar uma conta de usuário à instância, em "Autenticação integrada":
    4. Digite o nome de usuário DATABASE_USERNAME.
    5. Digite a senha DATABASE_PASSWORD
    6. Clique em Add.

    gcloud

    • Crie o usuário na instância criada recentemente:

      gcloud sql users create DATABASE_USERNAME \
          --instance INSTANCE_NAME \
          --password DATABASE_PASSWORD
      

      Substitua PASSWORD por uma senha segura.

Crie uma conta de serviço

Para usar o proxy, é necessário ter uma conta de serviço com privilégios de Editor para sua instância do Cloud SQL. Para mais informações sobre contas de serviço, consulte a visão geral da autenticação do Google Cloud.

  1. Acesse a página Contas de serviço no Console do Google Cloud.

    Acessar a página "Contas de serviço"

  2. Selecione o projeto que contém a instância do Cloud SQL.
  3. Clique em Criar conta de serviço.
  4. Na caixa de diálogo Criar conta de serviço, forneça um nome descritivo para a conta.
  5. Altere o ID da conta de serviço para um valor exclusivo e reconhecível e, em seguida, clique em Criar.
  6. Em Papel, selecione um dos seguintes papéis, clique em Continuar e em Concluído:
    • Cloud SQL > Cliente do Cloud SQL
    • Cloud SQL > Editor do Cloud SQL
    • Cloud SQL > Administrador do Cloud SQL
  7. Clique no menu de ações da sua nova conta de serviço e selecione Gerenciar chaves.
  8. Clique no menu suspenso Adicionar chave e clique em Criar nova chave.
  9. Confirme se o tipo de chave é JSON e clique em Criar.

    O arquivo da chave privada é transferido para sua máquina. Você pode movê-lo para outro local. Mantenha-o protegido.

Definir as configurações do banco de dados

Use os seguintes comandos para definir variáveis de ambiente para o acesso ao banco de dados. Essas variáveis são usadas para testes locais.

Linux/MacOS

export DATABASE_NAME=DATABASE_NAME
export DATABASE_USER=DATABASE_USERNAME
export DATABASE_PASSWORD=DATABASE_PASSWORD

Windows

set DATABASE_USER=DATABASE_USERNAME
set DATABASE_PASSWORD=DATABASE_PASSWORD

Definir a configuração do GKE

  1. Esse aplicativo é representado por uma única configuração do Kubernetes chamada polls. Em polls.yaml, substitua <your-project-id> pelo ID do projeto do Google Cloud (PROJECT_ID).

  2. Execute o comando a seguir e anote o valor de connectionName:

    gcloud sql instances describe INSTANCE_NAME --format "value(connectionName)"
    
  3. No arquivo polls.yaml, substitua <your-cloudsql-connection-string> pelo valor connectionName.

Executar o app no computador local

Com os serviços de backup configurados, agora você pode executar o app no seu computador. Essa configuração permite o desenvolvimento local, a criação de um superusuário e a aplicação de migrações de banco de dados.

  1. Em um terminal separado, inicie o proxy do Cloud SQL Auth:

    Linux/macOS

    ./cloud_sql_proxy -instances="PROJECT_ID:REGION:INSTANCE_NAME"=tcp:5432
    

    Windows

    cloud_sql_proxy.exe -instances="PROJECT_ID:REGION:INSTANCE_NAME"=tcp:5432
    

    Essa etapa estabelece uma conexão do seu computador local com a instância do Cloud SQL para testes locais. Mantenha o proxy do Cloud SQL Auth em execução durante todo o período de teste local do aplicativo. A execução desse processo em um terminal separado permite que você continue trabalhando enquanto esse processo é executado.

  2. Em um novo terminal, defina o ID do projeto localmente:

    Linux/macOS

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID
    

    Windows

      set GOOGLE_CLOUD_PROJECT=PROJECT_ID
    
  3. Execute as migrações do Django para configurar os modelos e os recursos:

    python manage.py makemigrations
    python manage.py makemigrations polls
    python manage.py migrate
    python manage.py collectstatic
    
  4. Inicie o servidor da Web Django:

    python manage.py runserver
    
  5. No navegador, acesse http://localhost:8000/.

    A página exibe o seguinte texto: "Hello, world. Você está no índice de pesquisas". O servidor da Web do Django em execução no seu computador exibe as páginas do aplicativo de amostra.

  6. Pressione Ctrl/Cmd+C para interromper o servidor da Web local.

Como usar o console de administração do Django

Para fazer login no Admin Console do Django, você precisa criar um superusuário. Como você tem uma conexão acessível localmente com o banco de dados, é possível executar comandos de gerenciamento:

  1. Crie um superusuário. Você será solicitado a inserir um nome de usuário, e-mail e senha.

    python manage.py createsuperuser
    
  2. Inicie um servidor da Web local:

    python manage.py runserver
    
  3. No navegador, acesse http://localhost:8000/admin.

  4. Faça login no site de administração usando o nome de usuário e a senha que você usou ao executar createsuperuser.

Implantar o app no GKE

Quando o aplicativo é implantado no Google Cloud, ele usa o servidor Gunicorn. Como o conteúdo estático não é transmitido pelo Gunicorn, o Cloud Storage é usado para disponibilizar esse tipo de conteúdo.

Coletar e fazer upload de recursos estáticos

  1. Crie um bucket do Cloud Storage e torne-o acessível para leitura pública.

    gsutil mb gs://PROJECT_ID_MEDIA_BUCKET
    gsutil defacl set public-read gs://PROJECT_ID_MEDIA_BUCKET
    
  2. Reúna todo o conteúdo estático em uma pasta.

    python manage.py collectstatic
    
  3. Faça o upload de todo conteúdo estático no Cloud Storage:

    gsutil -m rsync -r ./static gs://PROJECT_ID_MEDIA_BUCKET/static
    
  4. Em mysite/settings.py, defina o valor de STATIC_URL para o seguinte URL, substituindo [YOUR_GCS_BUCKET] pelo nome do bucket:

    http://storage.googleapis.com/PROJECT_ID_MEDIA_BUCKET/static/
    

Configurar o GKE

  1. Para inicializar o GKE, acesse a página Clusters.

    Acessar a página de Clusters

    Quando você usa o GKE pela primeira vez em um projeto, é necessário aguardar até que o "Kubernetes Engine está se preparando. Isso pode demorar alguns minutos" desapareça.

  2. Criar um cluster do GKE

    gcloud container clusters create polls \
      --scopes "https://www.googleapis.com/auth/userinfo.email","cloud-platform" \
      --num-nodes 4 --zone "us-central1-a"
    

    Você recebeu o erro: "Projeto [PROJECT_ID] não foi totalmente inicializado com as contas de serviço padrão"?

    Inicializar o GKE

    Se você recebeu um erro, acesse o Console do Google Cloud para inicializar o GKE no seu projeto.

    Acessar a página de Clusters

    Aguarde até que a mensagem "O Kubernetes Engine está se preparando. Isso pode levar alguns minutos" desapareça.

  3. Após a criação do cluster, use a ferramenta de linha de comando kubectl, integrada com a gcloud, para interagir com o cluster do GKE. Como gcloud e kubectl são ferramentas separadas, verifique se kubectl está configurado para interagir com o cluster certo.

    gcloud container clusters get-credentials polls --zone "us-central1-a"
    

Configurar o Cloud SQL

  1. Você precisa de várias chaves secretas para permitir que o aplicativo do GKE se conecte à instância do Cloud SQL. Uma delas é necessária para acesso de nível de instância (conexão), enquanto outras duas são necessárias para acesso a banco de dados. Para saber mais informações sobre os dois níveis de controle de acesso, consulte Controle de acesso à instância.

    1. Para criar o secret do acesso no nível da instância, forneça o local ([PATH_TO_CREDENTIAL_FILE]) da chave da conta de serviço JSON que você salvou ao criar essa conta. Consulte Como criar um serviço conta):

      kubectl create secret generic cloudsql-oauth-credentials \
        --from-file=credentials.json=[PATH_TO_CREDENTIAL_FILE]
      
    2. Para criar secrets para acesso ao banco de dados, use o banco de dados do SQL, o nome do usuário e a senha definidos na etapa 2 de Como inicializar a instância do Cloud SQL:

      kubectl create secret generic cloudsql \
        --from-literal=database=DATABASE_NAME \
        --from-literal=username=DATABASE_USERNAME \
        --from-literal=password=DATABASE_PASSWORD
      
  2. Recupere a imagem pública do Docker para o proxy do Cloud SQL.

    docker pull b.gcr.io/cloudsql-docker/gce-proxy
    
  3. Crie uma imagem do Docker, substituindo <your-project-id> pelo ID do projeto.

    docker build -t gcr.io/PROJECT_ID/polls .
    
  4. Configure o Docker para usar gcloud como um auxiliar de credenciais, de modo que você possa enviar a imagem para o Container Registry:

    gcloud auth configure-docker
    
  5. Envie a imagem do Docker. Substitua <your-project-id> pela ID do seu projeto.

    docker push gcr.io/PROJECT_ID/polls
    
  6. Crie o recurso do GKE:

    kubectl create -f polls.yaml
    

Implantar o app no GKE

Depois que os recursos forem criados, haverá três pods polls no cluster. Verifique o status dos seus pods.

kubectl get pods

Aguarde alguns minutos para que os status do pod sejam exibidos como Running. Se os pods não estiverem prontos ou se houver reinicializações, você poderá receber os registros de um pod específico para descobrir o problema. [YOUR-POD-ID] é uma parte da saída retornada pelo comando kubectl get pods anterior.

kubectl logs [YOUR_POD_ID]

Veja a execução do aplicativo no Google Cloud

Depois que os pods estiverem prontos, é possível saber o endereço IP público do balanceador de carga:

kubectl get services polls

Observe o endereço EXTERNAL-IP e acesse http://[EXTERNAL-IP] no navegador para ver a página de destino das enquetes do Django e acessar o Admin Console.

Entenda o código

Exemplo de aplicativo

O app de exemplo do Django foi criado com ferramentas padrão do Django. Os comandos a seguir criam o projeto e o aplicativo de pesquisa:

django-admin startproject mysite
python manage.py startapp polls

As visualizações básicas, os modelos e as configurações de rota foram copiados de Como criar seu primeiro aplicativo Django (Parte 1 e Parte 2).

Configuração do banco de dados

O settings.py contém a configuração para seu banco de dados SQL:

DATABASES = {
    'default': {
        # If you are using Cloud SQL for MySQL rather than PostgreSQL, set
        # 'ENGINE': 'django.db.backends.mysql' instead of the following.
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': os.getenv('DATABASE_NAME'),
        'USER': os.getenv('DATABASE_USER'),
        'PASSWORD': os.getenv('DATABASE_PASSWORD'),
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Configurações de pod do Kubernetes

O arquivo polls.yaml especifica dois recursos do Kubernetes. O primeiro é Serviço (em inglês), que define um nome consistente e um endereço IP privado para o app da Web em Django. O segundo é um balanceador de carga HTTP por um endereço IP externo público.

# The polls service provides a load-balancing proxy over the polls app
# pods. By specifying the type as a 'LoadBalancer', Kubernetes Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://kubernetes.io/docs/concepts/services-networking/service/
# For more information about external HTTP load balancing see:
#   https://kubernetes.io/docs/tasks/access-application-cluster/create-external-load-balancer/
apiVersion: v1
kind: Service
metadata:
  name: polls
  labels:
    app: polls
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: polls

Um nome de rede e um endereço IP são oferecidos pelo serviço e o código do aplicativo por trás do serviço são executados pelos pods do GKE. O arquivo polls.yaml especifica uma implantação que fornece atualizações declarativas para pods do GKE. O tráfego para a implantação é direcionado pelo serviço por meio da correspondência entre o seletor do serviço e o rótulo da implantação. Nesse caso, o seletor polls corresponde ao rótulo polls.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  selector:
    matchLabels:
      app: polls
  template:
    metadata:
      labels:
        app: polls
    spec:
      containers:
      - name: polls-app
        # Replace  with your project ID or use `make template`
        image: gcr.io/<your-project-id>/polls
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        env:
            - name: DATABASE_NAME
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: database
            - name: DATABASE_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: gcr.io/cloudsql-docker/gce-proxy:1.16
        name: cloudsql-proxy
        command: ["/cloud_sql_proxy", "--dir=/cloudsql",
                  "-instances=<your-cloudsql-connection-string>=tcp:5432",
                  "-credential_file=/secrets/cloudsql/credentials.json"]
        volumeMounts:
          - name: cloudsql-oauth-credentials
            mountPath: /secrets/cloudsql
            readOnly: true
          - name: ssl-certs
            mountPath: /etc/ssl/certs
          - name: cloudsql
            mountPath: /cloudsql
      volumes:
        - name: cloudsql-oauth-credentials
          secret:
            secretName: cloudsql-oauth-credentials
        - name: ssl-certs
          hostPath:
            path: /etc/ssl/certs
        - name: cloudsql
          emptyDir: {}

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir recursos individuais

Se você não quiser excluir o projeto, exclua os recursos individuais.

  1. Exclua o cluster do Google Kubernetes Engine:

    gcloud container clusters delete polls
    
  2. Exclua a imagem do Docker que você enviou para o Container Registry:

    gcloud container images delete gcr.io/PROJECT_ID/polls
    
  3. Exclua a instância do Cloud SQL:

    gcloud sql instances delete INSTANCE_NAME
    

A seguir