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.

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

Objetivos

Com este tutorial, você vai:

Criar e conectar um banco de dados do Cloud SQL.
Criar e usar valores de secret do Kubernetes.
Implantar um app Django no Google Kubernetes Engine.

Custos

Neste documento, você usará 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 estar qualificados para uma avaliação gratuita.

Antes de começar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud SQL, GKE and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Preparar o ambiente

Clonar um aplicativo de exemplo

O código do aplicativo de amostra Django está no repositório GoogleCloudPlatform/python-docs-samples no GitHub.

É 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
```

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.

Confirme se o Python contém a versão 3.7 ou posterior.
```
 python -V
```
Você verá Python 3.7.3 ou superior.

Observação: se você vir um número de versão que começa com "2", talvez seja necessário executar python3 em vez de python. Em caso afirmativo, consulte a instalação do Python escolhida ao executar comandos em python.

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 pela máquina local

Quando implantado, o aplicativo usa o proxy do Cloud SQL Auth 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 do 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 fazer isso, ele quer a autenticação do aplicativo pelo gcloud.

Autentique e receba as credenciais da API:
```
gcloud auth application-default login
```
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 e 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
```
Mac M1
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.arm64
  
```
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.30.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 no 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 de secrets que oferecem suporte ao 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 oficialmente oferece suporte a vários bancos de dados relacionais, mas oferece a maior parte do suporte para o PostgreSQL. O PostgreSQL conta com o suporte do 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, um banco de dados e um usuário do banco de dados do PostgreSQL para o aplicativo.

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 dos 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.
Na instância criada, crie um banco de dados:
Console
1. Na página da 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.
Crie um usuário de banco de dados:

Observação: os usuários criados dessa forma recebem direitos adicionais no banco de dados. Consulte Limitar os privilégios de usuário do banco de dados para ver um método alternativo.
Console
1. Na página da instância, acesse a guia Usuários.
2. Clique em Adicionar conta de usuário.
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. Insira a senha DATABASE_PASSWORD
6. Clique em Adicionar.
gcloud
- Crie o usuário na instância recém-criada:
```
gcloud sql users create DATABASE_USERNAME \
    --instance INSTANCE_NAME \
    --password DATABASE_PASSWORD
```
  Substitua PASSWORD por uma senha segura.

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 mais informações sobre contas de serviço, consulte a visão geral da autenticação do Google Cloud.

Se você estiver se conectando do Compute Engine, verifique se a VM tem o scope apropriado para se conectar usando a API Cloud SQL Admin.

Configure a conta de serviço para ter um dos seguintes escopos de acesso:

https://www.googleapis.com/auth/sqlservice.admin
https://www.googleapis.com/auth/cloud-platform

No Console do Cloud, acesse a página Contas de serviço.
Acessar Contas de serviço
Selecione o projeto que contém a instância do Cloud SQL.
Clique em Criar conta de serviço.
Preencha o campo Nome da conta de serviço.
Altere o ID da conta de serviço para um valor exclusivo e facilmente reconhecível, depois clique em Criar e continuar.
Clique no campo Selecionar papel e escolha um dos seguintes papéis:
- Cloud SQL > Cliente do Cloud SQL
- Cloud SQL > Editor do Cloud SQL
- Cloud SQL > Administrador do Cloud SQL
Clique em Concluído para terminar a criação da conta de serviço.
Clique no menu de ações da sua nova conta de serviço e selecione Gerenciar chaves.
Clique no menu suspenso Adicionar chave e clique em Criar nova chave.
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

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).

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

gcloud sql instances describe INSTANCE_NAME --format "value(connectionName)"

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 aplicativo 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.

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 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 teste local do aplicativo. A execução desse processo em um terminal separado permite que você continue trabalhando enquanto esse processo é executado.

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

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

Inicie o servidor da Web do Django:
```
python manage.py runserver
```
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.
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:

Crie um superusuário. Você será solicitado a inserir um nome de usuário, e-mail e senha.
```
python manage.py createsuperuser
```
Inicie um servidor da Web local:
```
python manage.py runserver
```
No navegador, acesse http://localhost:8000/admin.
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

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

Reúna todo o conteúdo estático em uma pasta.
```
python manage.py collectstatic
```

Faça o upload de todo conteúdo estático no Cloud Storage:

gsutil -m rsync -r ./static gs://PROJECT_ID_MEDIA_BUCKET/static

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

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.
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 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.
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

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
```
Recupere a imagem pública do Docker para o proxy do Cloud SQL.
```
docker pull b.gcr.io/cloudsql-docker/gce-proxy
```
Crie uma imagem do Docker, substituindo <your-project-id> pelo ID do projeto.
```
docker build -t gcr.io/PROJECT_ID/polls .
```
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
```
Envie a imagem do Docker. Substitua <your-project-id> pela ID do seu projeto.
```
docker push gcr.io/PROJECT_ID/polls
```
Observação: esse comando exige acesso de gravação ao Cloud Storage. Se você executar este tutorial em uma instância do Compute Engine, seu acesso ao Cloud Storage poderá ser somente leitura. Para ter acesso de gravação, crie uma conta de serviço e use-a para fazer a autenticação na instância.
Crie o recurso do GKE:
```
kubectl create -f polls.yaml
```
Observação: caso você tenha usado nomes diferentes (diferente de cloudsql-oauth-credentials e cloudsql) ao criar os secrets nos comandos anteriores, será necessário atualizar o arquivo polls.yaml para corresponder a esses novos nomes.

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:

kubernetes_engine/django_tutorial/mysite/settings.py

Ver no GitHub

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.

kubernetes_engine/django_tutorial/polls.yaml

Ver no GitHub

# 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.

kubernetes_engine/django_tutorial/polls.yaml

Ver no GitHub

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: {}

Limpar

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.

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Excluir recursos individuais

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

Exclua o cluster do Google Kubernetes Engine:
```
gcloud container clusters delete polls
```
Exclua a imagem do Docker que você enviou para o Container Registry:
```
gcloud container images delete gcr.io/PROJECT_ID/polls
```

Exclua a instância do Cloud SQL:

gcloud sql instances delete INSTANCE_NAME

A seguir

Saiba como configurar o PostgreSQL para produção
Saiba mais sobre o Django no Google Cloud.

Como executar o Django no Google Kubernetes Engine

Objetivos

Custos

Antes de começar

Preparar o ambiente

Clonar um aplicativo de exemplo

Linux/MacOS

Windows

Confirmar a configuração do Python

Linux/macOS

Windows

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

Linux de 64 bits

Linux de 32 bits

macOS de 64 bits

macOS de 32 bits

Mac M1

Windows de 64 bits

Windows de 32 bits

Imagem do Docker do proxy do Cloud SQL Auth

Outros SOs

Criar serviços de apoio

Configurar uma instância do Cloud SQL para PostgreSQL

Console

gcloud

Console

gcloud

Console

gcloud

Criar uma conta de serviço

Definir as configurações do banco de dados

Linux/MacOS

Windows

Definir a configuração do GKE

Executar o app no computador local

Linux/macOS

Windows

Linux/macOS

Windows

Como usar o console de administração do Django

Implantar o app no GKE

Coletar e fazer upload de recursos estáticos

Configurar o GKE

Inicializar o GKE

Configurar o Cloud SQL

Implantar o app no GKE

Veja a execução do aplicativo no Google Cloud

Entenda o código

Exemplo de aplicativo

Configuração do banco de dados

Configurações de pod do Kubernetes

Limpar

Excluir o projeto

Excluir recursos individuais

A seguir