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 5, que requer pelo menos o Python 3.10.

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ê vai 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 um teste sem custo financeiro.

Antes de começar

  1. Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloud, 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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud SQL, GKE and Compute Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. Instale a CLI gcloud.

  6. Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  7. Para inicializar a gcloud CLI, execute o seguinte comando: 

    gcloud init

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  9. Verify that billing is enabled for your Google Cloud project.

  10. Enable the Cloud SQL, GKE and Compute Engine APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  11. Instale a CLI gcloud.

  12. Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

  13. Para inicializar a gcloud CLI, execute o seguinte comando: 

    gcloud init

Preparar o ambiente

Clonar um aplicativo de exemplo

O código do app de exemplo Django está no repositório GoogleCloudPlatform/python-docs-samples 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.10 ou posterior.

     python -V

    Você verá Python 3.10.0 ou superior.

  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 venv
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 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 do proxy de autenticação do Cloud SQL.

O proxy de autenticação do Cloud SQL usa a API Cloud SQL para interagir com sua instância do SQL. Para fazer isso, ele quer a autenticação do aplicativo pela CLI 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 de autenticação do Cloud SQL: 
      curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.amd64
    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 de autenticação do Cloud SQL: 
      curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.linux.386
    2. Se o comando curl não for encontrado, execute sudo apt install curl 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 de autenticação do Cloud SQL: 
      curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.darwin.amd64
    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://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/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://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x64.exe e selecione Salvar link como para baixar o proxy de autenticação do Cloud SQL. Renomeie o arquivo para cloud-sql-proxy.exe.

    Windows de 32 bits

    Clique com o botão direito do mouse em https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.21.1/cloud-sql-proxy.x86.exe e selecione Salvar link como para baixar o proxy de autenticação do Cloud SQL. Renomeie o arquivo para cloud-sql-proxy.exe.

    Imagem Docker do proxy do Cloud SQL Auth

    O proxy do Cloud SQL Auth tem imagens de contêiner diferentes, como distroless, alpine e buster. A imagem de contêiner padrão do proxy do Cloud SQL Auth usa distroless, que não contém shell. Se você precisar de um shell ou de ferramentas relacionadas, faça o download de uma imagem baseada em alpine ou buster. Para mais informações, consulte Imagens de contêiner do proxy do Cloud SQL Auth.

    Você pode extrair a imagem mais recente para sua máquina local usando o Docker usando o seguinte comando:

    docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.21.1

    Outros SOs

    Para outros sistemas operacionais não incluídos aqui, compile o proxy do Cloud SQL Auth a partir do código-fonte.

    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.

  1. Crie a instância do PostgreSQL:

    Console

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

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

    2. Clique em Criar instância.

    3. Clique em Escolher PostgreSQL.

    4. Em Edição do SQL, escolha "Enterprise".

    5. Em Predefinição de edição, escolha "Sandbox".

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

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

    8. Mantenha os valores padrão dos outros campos.

    9. Clique em Criar instância.

    A instância leva alguns minutos para ficar pronta para uso.

    gcloud

    • Crie a instância do PostgreSQL:

      gcloud sql instances create INSTANCE_NAME \
    --project PROJECT_ID \
    --database-version POSTGRES_16 \
    --tier db-n1-standard-2 \
    --region REGION

    Substitua:

    • INSTANCE_NAME: o nome da instância do Cloud SQL.
    • PROJECT_ID: o ID do projeto Google Cloud
    • REGION: a regiãoGoogle 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 instância, acesse a guia Bancos de dados.
    2. Clique em Criar banco de dados.
    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 instância, acesse a guia Usuários.
    2. Clique em Adicionar conta de usuário.
    3. Na caixa de diálogo Escolha como autenticar, em "Autenticação integrada":
    4. Digite o nome de usuário DATABASE_USERNAME.
    5. Insira a senha DATABASE_PASSWORD
    6. Clique em Add.

    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.

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

  1. No console Google Cloud , acesse a página Contas de serviço.

    Acesse as 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. Preencha o campo Nome da conta de serviço.
  5. Altere o ID da conta de serviço para um valor exclusivo e facilmente reconhecível, depois clique em Criar e continuar.
  6. 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

  7. Clique em Concluído para terminar a criação da conta de serviço.
  8. Clique no menu de ações da sua nova conta de serviço e selecione Gerenciar chaves.
  9. Clique no menu suspenso Adicionar chave e clique em Criar nova chave.
  10. 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 projetoGoogle 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 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.

  1. Em um terminal separado, inicie o proxy de autenticação do Cloud SQL:

    Linux/macOS

    ./cloud-sql-proxy PROJECT_ID:REGION:INSTANCE_NAME

    Windows

    cloud-sql-proxy.exe PROJECT_ID:REGION:INSTANCE_NAME

    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.

  2. No terminal original, 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 do Django:

    python manage.py runserver 8080

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

    Se você estiver no Cloud Shell, clique no botão Visualização da Web e selecione Visualizar na porta 8080.

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

    gcloud storage buckets create gs://PROJECT_ID_MEDIA_BUCKET
gcloud storage buckets add-iam-policy-binding gs://PROJECT_ID_MEDIA_BUCKET --member=allUsers role=roles/storage.legacyObjectReader

  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:

    gcloud storage rsync ./static gs://PROJECT_ID_MEDIA_BUCKET/static --recursive

  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"

    Se uma mensagem de erro semelhante a Project is not fully initialized with the default service accounts aparecer, talvez seja necessário inicializar o Google Kubernetes Engine.

    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. Depois que o cluster for criado, use a ferramenta de linha de comando kubectl, integrada à CLI 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ê baixou ao criar essa conta. Consulte Como criar uma conta de serviço:

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

    2. Para criar os secrets para acesso ao banco de dados, use o banco de dados SQL, o nome de usuário e a senha definidos ao criar serviços de apoio. Consulte Configurar uma instância do Cloud SQL para PostgreSQL:

      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 o app em execução em Google Cloud

Depois que os pods estiverem prontos, é possível saber o endereço IP externo 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 é o Serviço, que define um nome consistente e um endereço IP interno para o app da Web em Django. O segundo é um balanceador de carga HTTP com 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.

Excluir o projeto

  1. No console Google 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