Como executar o Django no ambiente do Cloud Run

A implantação de aplicativos com estado no Cloud Run, como o Django, envolve a integração de serviços para interagir entre si para formar um projeto coeso.

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.

Objetivos

Com este tutorial, você vai:

  • Criar e conectar um banco de dados do Cloud SQL.
  • Criar e usar valores de secret do Secret Manager.

  • Implantar um app Django no Cloud Run.

  • Hospedar arquivos estáticos no Cloud Storage.

  • Usar o Cloud Build para automatizar a implantação.

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 Run, Cloud SQL, Cloud Build, Secret Manager, Artifact Registry, 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 Run, Cloud SQL, Cloud Build, Secret Manager, Artifact Registry, 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
  14. Verifique se as permissões suficientes estão disponíveis para a conta usada neste tutorial.

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/run/django

    Windows

    cd python-docs-samples\run\django

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

Neste tutorial, usamos os mecanismos integrados de hospedagem de recursos estáticos no Cloud Run.

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.

Configurar o Artifact Registry

Use o Artifact Registry para criar um registro e armazenar a imagem do contêiner.

Console

  1. No console do Google Cloud , acesse a página Artifact Registry.

    Acessar a página do Artifact Registry

  2. Clique em Criar repositório.

  3. Digite o seguinte:

    • Em Nome, digite "cloud-run-source-deploy".
    • Em Formato, selecione "Docker".
    • Em Região, selecione REGION.

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

  5. Clique em Criar.

gcloud

  • Crie um Artifact Registry:
gcloud artifacts repositories create cloud-run-source-deploy \
    --repository-format docker \
    --location REGION

Configurar um bucket do Cloud Storage

É possível armazenar recursos estáticos incluídos no Django e mídia enviada por usuários em armazenamento de objetos altamente disponível usando o Cloud Storage. O pacote django-storages[google] processa a interação do Django com esse back-end de armazenamento.

Console

  1. No console Google Cloud , acesse a página do Cloud Storage.

    Acessar a página do Cloud Storage

  2. Clique em Criar bucket.

  3. Insira o seguinte (clique em "Continuar" quando necessário):

    • Em Nome, digite "PROJECT_ID_MEDIA_BUCKET".
    • Em Região, selecione REGION.
    • Em Classe de armazenamento, mantenha os valores padrão.
    • Em Impedir acesso público, desmarque "Aplicar prevenção de acesso público".
    • Em Controle de acesso, selecione "Detalhado".

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

  5. Clique em Criar.

gcloud

  • Crie um bucket do Cloud Storage:

    gcloud storage buckets create gs://PROJECT_ID_MEDIA_BUCKET --location=REGION

    Substitua MEDIA_BUCKET por um sufixo para o bucket de mídia. Combinado com o ID do projeto, isso cria um nome de bucket exclusivo.

Armazenar valores do secret no Secret Manager

Agora que os serviços de backup estão configurados, o Django precisa de informações sobre esses serviços. Em vez de colocar esses valores diretamente no código-fonte do Django, este tutorial usa o Secret Manager para armazenar essas informações com segurança.

Criar o arquivo de ambiente Django como um secret do Secret Manager

Você armazena as configurações necessárias para iniciar o Django em um arquivo env protegido. O app de exemplo usa a API Secret Manager para recuperar o valor do secret e o pacote django-environ para carregar os valores no ambiente Django. O secret é configurado para ser acessível pelo Cloud Run e pelo Cloud Build.

  1. Crie um arquivo chamado .env, definindo a string de conexão do banco de dados, o nome do bucket de mídia e um novo valor SECRET_KEY:

    echo DATABASE_URL=postgres://DATABASE_USERNAME:DATABASE_PASSWORD@//cloudsql/PROJECT_ID:REGION:INSTANCE_NAME/DATABASE_NAME > .env
echo GS_BUCKET_NAME=PROJECT_ID_MEDIA_BUCKET >> .env
echo SECRET_KEY=$(cat /dev/urandom | LC_ALL=C tr -dc '[:alpha:]'| fold -w 50 | head -n1) >> .env

  2. Armazene o secret no Secret Manager:

    Console

    1. No console do Google Cloud , acesse a página do Secret Manager.

      Acessar a página "Gerenciador de secrets"

    2. Clique em Criar secret.

    3. No campo Nome, use django_settings.

    4. Na caixa de diálogo Valor do secret, cole o conteúdo do arquivo .env.

    5. Clique em Criar secret.

    6. Exclua o arquivo local para evitar modificações de configuração locais.

    gcloud

    1. Crie um novo secret, django_settings, com o valor do arquivo .env:

      gcloud secrets create django_settings --data-file .env

    2. Exclua o arquivo local para evitar modificações de configuração locais:

      rm .env

  3. Configure o acesso ao secret:

    Console

    1. Em Secret: django_settings, anote o número do projeto:

      projects/PROJECTNUM/secrets/django_settings

    2. Clique na guia Permissões.

    3. Clique em Conceder acesso.

    4. No campo Novos membros, digite PROJECTNUM-compute@developer.gserviceaccount.com e pressione Enter.

    5. No menu suspenso Papel, selecione Acessador de secrets do Secret Manager.

    6. Clique em Salvar.

    gcloud

    1. Encontre o valor do número do projeto (PROJECTNUM):

      gcloud projects describe PROJECT_ID --format='value(projectNumber)'

    1. Conceda acesso ao secret para a conta de serviço do Cloud Run:

      gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:PROJECTNUM-compute@developer.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

    Na saída, confirme se bindings lista a nova conta de serviço.

Criar um secret para a senha de administrador do Django

O usuário administrador do Django normalmente é criado executando o comando de gerenciamento interativo createsuperuser.

Este tutorial usa uma migração de dados para criar o usuário administrador, recuperando a senha de administrador no Secret Manager.

Console

  1. No console do Google Cloud , acesse a página do Secret Manager.

  2. Clique em Criar secret.

  3. No campo Nome, use superuser_password.

  4. No campo Valor do secret, insira uma senha aleatória e única.

  5. Clique em Criar secret.

  6. Em Detalhes da superuser_password, anote o número do projeto (projects/PROJECTNUM/secrets/superuser_password).

  7. Clique na guia Permissões.

  8. Clique em Adicionar.

  9. No campo Novos membros, digite PROJECTNUM-compute@developer.gserviceaccount.com e pressione Enter.

  10. No menu suspenso Papel, selecione Acessador de secrets do Secret Manager.

  11. Clique em Save.

gcloud

  1. Crie um novo secret, superuser_password, a partir de uma senha gerada aleatoriamente:

    echo -n "$(cat /dev/urandom | LC_ALL=C tr -dc '[:alpha:]'| fold -w 30 | head -n1)" | gcloud secrets create superuser_password --data-file -

  2. Conceda acesso ao secret do Cloud Build:

    gcloud secrets add-iam-policy-binding superuser_password \
    --member serviceAccount:PROJECTNUM-compute@developer.gserviceaccount.com \
    --role roles/secretmanager.secretAccessor

    Na saída, confirme se bindings lista apenas o Cloud Build como membro.

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 e a aplicação de migrações de banco de dados. As migrações de banco de dados também são aplicadas no Cloud Build, mas você precisará ter essa configuração local para usar makemigrations.

  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 (usado pela API Secret Manager):

    Linux/macOS

    export GOOGLE_CLOUD_PROJECT=PROJECT_ID

    Windows

    set GOOGLE_CLOUD_PROJECT=PROJECT_ID

  3. Defina uma variável de ambiente para indicar que você está usando o proxy do Cloud SQL Auth (esse valor é reconhecido no código):

    Linux/macOS

    export USE_CLOUD_SQL_AUTH_PROXY=true

    Windows

    set USE_CLOUD_SQL_AUTH_PROXY=true

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

  5. Inicie o servidor da Web do Django:

    python manage.py runserver 8080

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

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

Implantar o app no Cloud Run

Com a configuração de serviços de apoio, é possível implantar o serviço Cloud Run.

  1. Usando o cloudmigrate.yaml fornecido, use o Cloud Build para criar a imagem, executar as migrações do banco de dados e preencher os recursos estáticos:

    gcloud builds submit --config cloudmigrate.yaml \
    --substitutions _INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION

    A primeira versão leva alguns minutos para ser concluída.

  2. Quando a criação for bem-sucedida, implante o serviço Cloud Run pela primeira vez, definindo a região de serviço, a imagem de base e a instância do Cloud SQL conectada:

    gcloud run deploy polls-service \
    --region REGION \
    --image REGION-docker.pkg.dev/PROJECT_ID/cloud-run-source-deploy/polls-service \
    --add-cloudsql-instances PROJECT_ID:REGION:INSTANCE_NAME \
    --allow-unauthenticated

    Será exibida a resposta que mostra a implantação bem-sucedida, com o URL de serviço:

    Service [polls-service] revision [polls-service-00001-tug] has been deployed
and is serving 100 percent of traffic.
Service URL: https://polls-service-PROJECT_ID.REGION.run.app

  3. Atualize o serviço para os URLs de serviço como uma variável de ambiente.

    CLOUDRUN_SERVICE_URLS=$(gcloud run services describe polls-service \
    --region $REGION  \
    --format "value(metadata.annotations[\"run.googleapis.com/urls\"])" | tr -d '"[]')

gcloud run services update polls-service \
    --region REGION \
    --update-env-vars "^##^CLOUDRUN_SERVICE_URLS=$CLOUDRUN_SERVICE_URLS"

  4. Para ver o serviço implantado, acesse o URL do serviço.

  5. Para fazer login no administrador do Django, anexe /admin ao URL, faça login com o nome de usuário admin e a senha definida anteriormente.

    Para recuperar a senha de superusuário do Secret Manager:

    gcloud secrets versions access latest --secret superuser_password && echo ""

Atualização do aplicativo

Embora as etapas iniciais de provisionamento e implantação tenham sido complexas, fazer atualizações é um processo mais simples:

  1. Execute o script de criação e migração do Cloud Build:

    gcloud builds submit --config cloudmigrate.yaml \
    --substitutions _INSTANCE_NAME=INSTANCE_NAME,_REGION=REGION

  2. Implante o serviço, especificando apenas a região e a imagem:

    gcloud run deploy polls-service \
    --region REGION \
    --image REGION-docker.pkg.dev/PROJECT_ID/cloud-run-source-deploy/polls-service

Como configurar para produção

Agora você tem uma implantação do Django funcionando, mas pode seguir algumas etapas para garantir que seu aplicativo esteja pronto para produção.

Desativar depuração

Confirme se a variável DEBUG em mysite/settings.py está definida como False. Isso impedirá que as páginas de erro detalhadas sejam exibidas para o usuário, o que pode vazar informações sobre as configurações.

Limitar os privilégios de usuário do banco de dados

Todos os usuários criados com o Cloud SQL têm os privilégios associados ao papel cloudsqlsuperuser: CREATEROLE, CREATEDB e LOGIN.

Para impedir que o usuário do banco de dados do Django tenha essas permissões, crie-o manualmente no PostgreSQL. Você precisará ter o terminal interativo psql instalado ou usar o Cloud Shell com essa ferramenta pré-instalada.

Console

  1. No console do Google Cloud , ative o Cloud Shell.

    Ativar o Cloud Shell

  2. No Cloud Shell, use o terminal integrado para se conectar à instância INSTANCE_NAME:

    gcloud sql connect INSTANCE_NAME --user postgres

  3. Insira a senha do usuário do postgres.

    Agora você está usando o psql. Você verá o prompt postgres=>.

  4. Crie um usuário:

    CREATE USER DATABASE_USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

    Substitua PASSWORD por uma senha aleatória e exclusiva.

  5. Conceda direitos totais sobre o novo banco de dados para o novo usuário:

    GRANT ALL PRIVILEGES ON DATABASE DATABASE_NAME TO DATABASE_USERNAME;

  6. Saia de psql:

    \q

gcloud

  1. Inicie uma conexão com a instância do SQL:

    gcloud sql connect INSTANCE_NAME --user postgres

    Substitua INSTANCE_NAME pela instância criada do Cloud SQL.

  2. Insira a senha do usuário do postgres.

    Agora você está usando o psql. Você verá o prompt postgres=>.

  3. Crie um usuário:

    CREATE USER DATABASE_USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

  4. Conceda direitos totais sobre o novo banco de dados para o novo usuário:

    GRANT ALL PRIVILEGES ON DATABASE DATABASE_NAME TO DATABASE_USERNAME;

  5. Saia de psql:

    \q

Como definir permissões mínimas

Por padrão, esse serviço é implantado com a conta de serviço de computação padrão. No entanto, em alguns casos, o uso da conta de serviço padrão pode fornecer muitas permissões. Se você quiser ser mais restritivo, será necessário criar sua própria conta de serviço e atribuir apenas as permissões exigidas pelo serviço. As permissões necessárias podem variar de serviço para serviço, dependendo dos recursos usados por um determinado serviço.

Os papéis mínimos do projeto exigidos por este serviço são os seguintes:

  • Chamador do Cloud Run
  • Cliente do Cloud SQL
  • Administrador do Storage, no bucket de mídia
  • Acessador de Secret Manager, no secret de configurações do Django. O acesso ao secret do administrador do Django não é exigido pelo próprio serviço.

Para criar uma conta de serviço com as permissões necessárias e atribuí-la ao serviço, execute este comando:

  1. Na CLI gcloud, crie uma conta de serviço com os papéis necessários:

    gcloud iam service-accounts create polls-service-account
SERVICE_ACCOUNT=polls-service-account@PROJECT_ID.iam.gserviceaccount.com

# Cloud SQL Client
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/cloudsql.client

# Storage Admin, on the media bucket
gcloud storage buckets add-iam-policy-binding gs://MEDIA_BUCKET \
    --member=serviceAccount:${SERVICE_ACCOUNT} \
    --role=roles/storage.objectAdmin

# Secret Accessor, on the Django settings secret.
gcloud secrets add-iam-policy-binding django_settings \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/secretmanager.secretAccessor

# Secret Accessor, on the Django super user password.
gcloud secrets add-iam-policy-binding superuser_password \
    --member serviceAccount:${SERVICE_ACCOUNT} \
    --role roles/secretmanager.secretAccessor

  2. Implante o serviço, associando-o à nova conta de serviço:

    gcloud run services update polls-service \
    --region REGION \
    --service-account ${SERVICE_ACCOUNT}

  3. Atualize os jobs do Cloud Run em cloudmigrate.yaml para também ter essa configuração --service-account.

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

Secrets do Secret Manager

O arquivo settings.py contém o código que usa a API Secret Manager Python para recuperar a versão mais recente do secret nomeado e extraí-la para o ambiente (usando django-environ):

# SECURITY WARNING: don't run with debug turned on in production!
# Change this to "False" when you are ready for production
env = environ.Env(DEBUG=(bool, True))
env_file = os.path.join(BASE_DIR, ".env")

# Attempt to load the Project ID into the environment, safely failing on error.
try:
    _, os.environ["GOOGLE_CLOUD_PROJECT"] = google.auth.default()
except google.auth.exceptions.DefaultCredentialsError:
    pass

if os.path.isfile(env_file):
    # Use a local secret file, if provided

    env.read_env(env_file)
# ...
elif os.environ.get("GOOGLE_CLOUD_PROJECT", None):
    # Pull secrets from Secret Manager
    project_id = os.environ.get("GOOGLE_CLOUD_PROJECT")

    client = secretmanager.SecretManagerServiceClient()
    settings_name = os.environ.get("SETTINGS_NAME", "django_settings")
    name = f"projects/{project_id}/secrets/{settings_name}/versions/latest"
    payload = client.access_secret_version(name=name).payload.data.decode("UTF-8")

    env.read_env(io.StringIO(payload))
else:
    raise Exception("No local .env or GOOGLE_CLOUD_PROJECT detected. No secrets found.")

O secret foi usado para armazenar diversos valores de secret para reduzir o número de diferentes secrets que precisavam ser configurados.

Configurações de CSRF

O Django tem proteção integrada contra falsificação de solicitação entre sites (CSRF). A partir do Django 4.0, as mudanças na forma como isso funciona significam que é importante informar ao Django qual é o URL hospedado para que ele possa oferecer as melhores proteções aos usuários que enviam dados.

Você fornece o URL do app como uma variável de ambiente no arquivo settings.py. Esse é o valor que o Django usa para as configurações relevantes.

# SECURITY WARNING: It's recommended that you use this when
# running in production. The URLs will be known once you first deploy
# to Cloud Run. This code takes the URLs and converts it to both these settings formats.
CLOUDRUN_SERVICE_URLS = env("CLOUDRUN_SERVICE_URLS", default=None)
if CLOUDRUN_SERVICE_URLS:
    CSRF_TRUSTED_ORIGINS = env("CLOUDRUN_SERVICE_URLS").split(",")
    # Remove the scheme from URLs for ALLOWED_HOSTS
    ALLOWED_HOSTS = [urlparse(url).netloc for url in CSRF_TRUSTED_ORIGINS]

    SECURE_SSL_REDIRECT = True
    SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
else:
    ALLOWED_HOSTS = ["*"]

Substituições de secret local

Se um arquivo .env for encontrado no sistema de arquivos local, ele será usado no lugar do valor do Secret Manager. Criar um arquivo .env localmente pode ajudar com testes locais. Por exemplo, desenvolvimento local em um banco de dados SQLite ou outras configurações locais.

Conexão com o banco de dados

O arquivo settings.py contém a configuração do banco de dados SQL. Ele usa o auxiliar env.db() de django-environ para carregar a string de conexão definida em DATABASE_URL na configuração DATABASES.

Ao executar o aplicativo localmente e usar o proxy de autenticação do Cloud SQL para acessar o banco de dados hospedado, a flag USE_CLOUD_SQL_AUTH_PROXY ajusta as configurações do banco de dados para usar o proxy.

# Use django-environ to parse the connection string
DATABASES = {"default": env.db()}

# If the flag as been set, configure to use proxy
if os.getenv("USE_CLOUD_SQL_AUTH_PROXY", None):
    DATABASES["default"]["HOST"] = "127.0.0.1"
    DATABASES["default"]["PORT"] = 5432

Estática, armazenada em nuvem

O arquivo settings.py também usa django-storages para integrar o bucket de mídia do Cloud Storage diretamente ao projeto:

# Define static storage via django-storages[google]
GS_BUCKET_NAME = env("GS_BUCKET_NAME")
STATIC_URL = "/static/"
STORAGES = {
    "default": {
        "BACKEND": "storages.backends.gcloud.GoogleCloudStorage",
    },
    "staticfiles": {
        "BACKEND": "storages.backends.gcloud.GoogleCloudStorage",
    },
}
GS_DEFAULT_ACL = "publicRead"

Automação com o Cloud Build

O cloudmigrate.yaml processa todas as etapas necessárias para criar uma nova imagem de contêiner e usá-la para aplicar migrações de banco de dados.

Neste tutorial, optamos por usar buildpacks para criar a imagem de contêiner e pontos de entrada personalizados no Procfile para processar comandos de gerenciamento. Eles podem ser referenciados por jobs do Cloud Run para executar os comandos.

steps:
  - id: "Build Container Image"
    name: gcr.io/k8s-skaffold/pack
    args: ["build", "${_IMAGE_NAME}", "--builder=gcr.io/buildpacks/builder"]

  - id: "Push Container Image"
    name: "gcr.io/cloud-builders/docker"
    args: ["push", "${_IMAGE_NAME}"]

  - id: "Migrate database"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: /bin/bash
    args:
      - "-c"
      - |
        gcloud run jobs create migrate-job \
          --region ${_REGION} \
          --image ${_IMAGE_NAME} \
          --set-cloudsql-instances ${_CLOUD_SQL_CONNECTION_NAME} \
          --set-env-vars SETTINGS_NAME=${_SECRET_SETTINGS_NAME} \
          --command migrate \
          --execute-now

  - id: "Create superuser"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: /bin/bash
    args:
      - "-c"
      - |
        gcloud run jobs create superuser-job \
          --region ${_REGION} \
          --image ${_IMAGE_NAME} \
          --set-cloudsql-instances ${_CLOUD_SQL_CONNECTION_NAME} \
          --set-env-vars SETTINGS_NAME=${_SECRET_SETTINGS_NAME} \
          --set-env-vars DJANGO_SUPERUSER_EMAIL=${_ADMIN_EMAIL} \
          --set-secrets DJANGO_SUPERUSER_PASSWORD=${_ADMIN_PASSWORD_NAME}:latest \
          --command createsuperuser \
          --execute-now

options:
  dynamicSubstitutions: true

substitutions:
  _INSTANCE_NAME: django-instance
  _CLOUD_SQL_CONNECTION_NAME: ${PROJECT_ID}:${_REGION}:${_INSTANCE_NAME}
  _REGION: us-central1
  _SERVICE_NAME: polls-service
  _SECRET_SETTINGS_NAME: django_settings
  _ARTIFACT_REGISTRY: cloud-run-source-deploy
  _IMAGE_NAME: ${_REGION}-docker.pkg.dev/${PROJECT_ID}/${_ARTIFACT_REGISTRY}/${_SERVICE_NAME}
  _ADMIN_EMAIL: example@example.com
  _ADMIN_PASSWORD_NAME: superuser_password

images:
  - "${_IMAGE_NAME}"

Variáveis de substituição são usadas nessa configuração.

Criação de superusuário com jobs do Cloud Run

O comando de gerenciamento do Django createsuperuser pode ser executado de forma não interativa definindo DJANGO_SUPERUSER_EMAIL e DJANGO_SUPERUSER_PASSWORD.

Neste tutorial, optamos por usar jobs do Cloud Run para executar esse comando. Isso é feito adicionando uma entrada personalizada ao Procfile, que executa createsuperuser.

# Create superuser (requires DJANGO_SUPERUSER_PASSWORD and DJANGO_SUPERUSER_EMAIL envvars)
createsuperuser: python manage.py createsuperuser --username admin --noinput || echo "User already exists."

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.

A seguir