Como executar o Django no Kubernetes Engine

É fácil começar a desenvolver aplicativos Django executáveis no Google Kubernetes Engine. Como os aplicativos criados são executados na mesma infraestrutura usada para todos os produtos do Google, você pode contar com a escalonabilidade necessária para atender a todos os seus usuários, sejam eles dezenas ou milhões.

Neste tutorial, julgamos que você esteja familiarizado com o desenvolvimento de Web com Django. Nele, você verá como implantar o aplicativo de tutorial oficial do Django (em inglês).

É uma boa ideia ver esse tutorial antes deste aqui, especialmente se você é novo no desenvolvimento do Django. Os modelos do aplicativo representam pesquisas com questões, e você pode interagir com eles. Basta usar o console de administração do Django.

Neste tutorial, é necessário usar o Python 2.7, 3.4 ou versão posterior (em inglês). Também é necessário ter o Docker instalado (em inglês).

Antes de começar

Marque as etapas conforme elas forem concluídas.

  1. check_box_outline_blank check_box Criar um projeto no Console do Google Cloud Platform.
    Caso ainda não tenha feito isso, crie um agora. Com os projetos, você gerencia todos os recursos do Google Cloud Platform para seu app, incluindo implantação, controle de acesso, faturamento e serviços.
    1. Abra o Console do GCP.
    2. No menu suspenso na parte superior, selecione Criar um projeto.
    3. Clique em Mostrar opções avançadas. Em Local do App Engine, selecione um local no Brasil.
    4. Dê um nome ao projeto.
    5. Anote o ID do projeto, que pode ser diferente do nome do projeto. Esse ID é usado em comandos e configurações.
  2. check_box_outline_blank check_box Ativar o faturamento para o projetoe inscrever-se para uma avaliação gratuita.

    Caso ainda não tenha feito isso, ative o faturamento agora e inscreva-se para uma avaliação gratuita. A ativação do faturamento permite que recursos passíveis de cobrança, como execução de instâncias e armazenamento de dados, sejam usados no aplicativo. Você não será cobrado por qualquer serviço durante o período da avaliação gratuita.

  3. check_box_outline_blank check_box Instalar o SDK do Cloud.

    Instale e inicialize o SDK do Cloud agora, caso ainda não tenha feito isso. O SDK do Cloud contém ferramentas e bibliotecas que podem ser usadas para criar e gerenciar recursos no GCP.

  4. check_box_outline_blank check_box Ativar as APIs do projeto.

    Isso direciona você para o Console do GCP e ativa as APIs usadas neste tutorial: API do Cloud SQL e API do Compute Engine.

Como fazer o download e executar o app

Depois de concluir os pré-requisitos, faça o download e implante o app de amostra do Django. Veja nas seções a seguir como configurar, executar e implantar o exemplo.

Como clonar o app do Django

O código para o aplicativo de amostra do Django está no repositório GCP Python Samples no GitHub.

Clone o repositório na sua máquina local:

git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

Acesse o diretório que contém o código de amostra:

cd python-docs-samples/container_engine/django_tutorial

Uma alternativa é fazer o download da amostra (em inglês) como arquivo zip e extraí-lo.

Como configurar o ambiente local

Quando implantado, seu aplicativo usa o Cloud SQL Proxy incorporado ao ambiente do App Engine para se comunicar com sua 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.

Saiba mais sobre o Cloud SQL Proxy.

Para executar tarefas administrativas básicas na sua instância do Cloud SQL, use o cliente PostgreSQL.

Como instalar o Cloud SQL Proxy

Faça o download do Cloud SQL Proxy e instale-o. Ele se conectará à sua instância do Cloud SQL durante a execução local.

Linux de 64 bits

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

Linux de 32 bits

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

macOS de 64 bits

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

macOS de 32 bits

  1. Faça o download do proxy: 
    curl -o cloud_sql_proxy https://dl.google.com/cloudsql/cloud_sql_proxy.darwin.386
  2. Torne o proxy 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. 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. Renomeie o arquivo para cloud_sql_proxy.exe.
Caso seu sistema operacional não esteja incluído aqui, compile o proxy a partir da fonte (em inglês).

Como criar uma instância do Cloud SQL

  1. Crie uma instância do Cloud SQL para PostgreSQL.

    Atribua à instância o nome polls-instance ou outro similar. Pode demorar alguns minutos para a instância ficar pronta. Quando isso acontecer, ela estará visível na lista de instâncias.

  2. Agora, use o SDK do Cloud para executar o seguinte comando, em que [YOUR_INSTANCE_NAME] representa o nome da sua instância do Cloud SQL. 
    gcloud sql instances describe [YOUR_INSTANCE_NAME]

    Na saída, observe o valor mostrado para [CONNECTION_NAME].

    O valor de [CONNECTION_NAME] está no formato [PROJECT_NAME]:[REGION_NAME]:[INSTANCE_NAME].

Como inicializar a instância do Cloud SQL

  1. Inicie o Cloud SQL Proxy usando o valor [CONNECTION_NAME] da etapa anterior.

    Linux/macOS

    ./cloud_sql_proxy -instances="[YOUR_INSTANCE_CONNECTION_NAME]"=tcp:5432

    Windows

    cloud_sql_proxy.exe -instances="[YOUR_INSTANCE_CONNECTION_NAME]"=tcp:5432

    Substitua [YOUR_INSTANCE_CONNECTION_NAME] pelo valor de [CONNECTION_NAME] registrado na etapa anterior.

    Essa etapa estabelece uma conexão do computador local com a instância do Cloud SQL para testes locais. Mantenha o Cloud SQL Proxy em execução durante todo o teste local do aplicativo.

  2. Crie um usuário e um banco de dados do Cloud SQL.

    Console do GCP

    1. Crie um novo banco de dados usando o Console do GCP para a instância de polls-instance do Cloud SQL. Por exemplo, você pode usar o nome polls.
    2. Crie um novo usuário usando o Console do GCP para a instância de polls-instance do Cloud SQL.

    Cliente Postgres

    1. Em uma guia de linha de comando separada, instale o cliente Postgres (em inglês). 
      sudo apt-get install postgresql
    2. Use o cliente Postgres ou programa semelhante para se conectar à instância. Quando solicitado, use a senha raiz configurada. 
      psql --host 127.0.0.1 --user postgres --password
    3. Crie os bancos de dados, usuários e permissões de acesso necessários no banco de dados do Cloud SQL usando os comandos a seguir. Substitua [POSTGRES_USER] e [POSTGRES_PASSWORD] pelo nome de usuário e senha que você quer usar. 
      CREATE DATABASE polls;
CREATE USER [POSTGRES_USER] WITH PASSWORD '[POSTGRES_PASSWORD]';
GRANT ALL PRIVILEGES ON DATABASE polls TO [POSTGRES_USER];
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO [POSTGRES_USER];

Como criar 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 saber mais sobre contas de serviço, consulte o Guia de autenticação do GCP.

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

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

  2. Se necessário, 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. Em Papel, selecione um dos seguintes papéis:
    • Cloud SQL > Cliente do Cloud SQL
    • Cloud SQL > Editor do Cloud SQL
    • Cloud SQL > Administrador do Cloud SQL
  6. Altere o ID da conta de serviço com um valor exclusivo que você possa reconhecer para que seja mais fácil encontrar essa conta de serviço mais tarde, se necessário.
  7. Clique em Fornecer uma nova chave privada.
  8. O tipo de chave padrão é JSON, que é o valor correto a ser usado.
  9. Clique em Criar.

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

Como definir as configurações do banco de dados

  1. Defina variáveis de ambiente para o acesso ao banco de dados para teste local.

Linux/MacOS

export DATABASE_USER=<your-database-user>
export DATABASE_PASSWORD=<your-database-password>

Windows

set DATABASE_USER=<your-database-user>
set DATABASE_PASSWORD=<your-database-password>

Como definir sua 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.

  2. Em polls.yaml, substitua a <your-cloudsql-connection-string> pelo valor do connectionName gerado pelo comando abaixo:

    gcloud beta sql instances describe [YOUR_INSTANCE_NAME]

Como executar o app no computador local

  1. Para executar o app do Django no seu computador local, configure um ambiente de desenvolvimento do Python, incluindo Python, pip e virtualenv.

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

    virtualenv env
source env/bin/activate
pip install -r requirements.txt

  3. Execute as migrações do Django para definir seus modelos:

    python manage.py makemigrations
python manage.py makemigrations polls
python manage.py migrate

  4. Inicie um servidor da Web local:

    python manage.py runserver

  5. No navegador, acesse http://localhost:8000/.

Uma página da Web simples é exibida com o seguinte texto: "Hello, world. You're at the polls index." As páginas do app de amostra são entregues pelo servidor da Web do Django em execução no seu computador. Quando estiver pronto para avançar, pressione Ctrl+C para interromper o servidor da Web local.

Como usar o console de administração do Django

  1. Crie um superusuário:

    python manage.py createsuperuser

  2. Execute o programa principal:

    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 criados durante a execução de createsuperuser.

Como implantar o app no GKE

  1. Quando o aplicativo é implantado no Google Cloud Platform, 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.

    Crie um intervalo do Cloud Storage e torne-o acessível para leitura pública. Substitua <your-gcs-bucket> pelo nome de intervalo da sua preferência. Por exemplo, você pode usar seu ID do projeto como um nome de intervalo:

    gsutil mb gs://<your-gcs-bucket>
gsutil defacl set public-read gs://<your-gcs-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 rsync -R static/ gs://<your-gcs-bucket>/static

  4. Em mysite/settings.py, defina o valor de STATIC_URL para o URL a seguir, substituindo <your-gcs-bucket> pelo nome do seu intervalo.

    http://storage.googleapis.com/<your-gcs-bucket>/static/

  5. Para inicializar o GKE, acesse o Console do GCP. Aguarde até que a mensagem "O Kubernetes Engine está se preparando. Isso pode demorar alguns minutos" desapareça.

  6. Crie 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 {container_name_short}}

    Se você recebeu um erro, visite o console para inicializar o GKE no seu projeto:

    Acessar a página do GKE

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

  7. Depois que o cluster for criado, use a ferramenta de linha de comando kubectl, que é integrada à ferramenta gcloud, para interagir com seu cluster do GKE. Como a gcloud e a kubectl são ferramentas separadas, verifique se a kubectl está configurado para interagir com o cluster certo:

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

  8. 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 no nível da instância (conexão) e outras duas para acesso ao 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 a chave secreta para acesso no nível da instância, informe o local onde você salvou a chave quando criou sua conta de serviço:

      kubectl create secret generic cloudsql-oauth-credentials --from-file=credentials.json=[PATH_TO_CREDENTIAL_FILE]

    2. Crie as chaves secretas necessárias para acesso ao banco de dados:

      kubectl create secret generic cloudsql --from-literal=username=[PROXY_USERNAME] --from-literal=password=[PASSWORD]

  9. Recupere a imagem pública do Docker para o proxy do Cloud SQL.

    docker pull b.gcr.io/cloudsql-docker/gce-proxy:1.05

  10. Crie uma imagem Docker, substituindo <your-project-id> pelo ID do projeto.

    docker build -t gcr.io/<your-project-id>/polls .

  11. Configure o docker para usar a gcloud como um auxiliar de credencial. Isso permitirá enviar a imagem para o Google Container Registry:

    gcloud auth configure-docker

  12. Envie a imagem do Docker. Substitua <your-project-id> pelo ID do projeto.

    docker push gcr.io/<your-project-id>/polls

  13. Crie o recurso do GKE:

    kubectl create -f polls.yaml

  14. É preciso haver três pods polls no cluster depois da criação dos recursos. Verifique o status dos seus pods.

    kubectl get pods

    Aguarde alguns minutos até que os status dos pods sejam Running. Se os pods não ficarem prontos ou se houver reinicializações, consulte os registros de um pod em particular para descobrir o problema:

    kubectl logs <your-pod-id>

Como ver o app executado no GCP

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

kubectl get services polls

Acesse o endereço EXTERNAL-IP no navegador para ver a página de destino básica do Django e acessar o console de administração.

Como entender o código

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

django-admin startproject mysite
python manage.py startapp polls

A configuração para o banco de dados SQL está contida no settings.py:

container_engine/django_tutorial/mysite/settings.py 
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': 'polls',
        'USER': os.getenv('DATABASE_USER'),
        'PASSWORD': os.getenv('DATABASE_PASSWORD'),
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Dois recursos do Kubernetes são especificados pelo arquivo polls.yaml. 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, com um endereço IP externo público.

container_engine/django_tutorial/polls.yaml 
# The polls service provides a load-balancing proxy over the polls app
# pods. By specifying the type as a 'LoadBalancer', Container Engine will
# create an external HTTP load balancer.
# For more information about Services see:
#   https://cloud.google.com/container-engine/docs/services/
# For more information about external HTTP load balancing see:
#   https://cloud.google.com/container-engine/docs/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 a implantação (em inglês) em que atualizações declarativas são geradas para os 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. Neste caso, o seletor polls corresponde ao rótulo polls.

container_engine/django_tutorial/polls.yaml 
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  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_USER
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: username
            - name: DATABASE_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: cloudsql
                  key: password
        ports:
        - containerPort: 8080

      - image: b.gcr.io/cloudsql-docker/gce-proxy:1.05
        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:
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Esta página
Comentários sobre a documentação
Python
Comentários sobre o produto