1. Introdução
Última atualização: 01/11/2024
Como modernizar um aplicativo PHP antigo para o Google Cloud?
(📽️ assista a um vídeo introdutório de 7 minutos sobre este codelab)
É comum ter aplicativos legados em execução no local que precisam ser modernizados. Isso significa torná-los escalonáveis, seguros e implantáveis em diferentes ambientes.
Neste workshop, você vai:
- Conteinerizar o aplicativo PHP.
- Migrar para um serviço de banco de dados gerenciado (Cloud SQL).
- Implantar no Cloud Run (uma alternativa sem operações ao GKE/Kubernetes).
- Proteger o aplicativo com o Identity and Access Management (IAM) e o Secret Manager.
- Definir um pipeline de CI/CD usando o Cloud Build. O Cloud Build pode ser conectado ao seu repositório Git hospedado em provedores conhecidos, como GitHub ou GitLab, e ser acionado em qualquer push para o main, por exemplo.
- Hospedar as imagens do aplicativo no Cloud Storage. Isso é feito por meio da montagem, e nenhum código é necessário para mudar o app.
- Introduzir a funcionalidade de IA generativa com o Gemini, orquestrada pelo Cloud Functions (sem servidor).
- Familiarize-se com os SLOs e a operação do app recém-atualizado.
Seguindo essas etapas, você pode modernizar gradualmente seu aplicativo PHP, melhorando a escalonabilidade, a segurança e a flexibilidade de implantação. Além disso, ao migrar para o Google Cloud, você pode aproveitar a infraestrutura e os serviços avançados dele para garantir que o aplicativo seja executado sem problemas em um ambiente nativo da nuvem.
Acreditamos que o que você vai aprender seguindo estas etapas simples pode ser aplicado ao seu próprio aplicativo e organização com diferentes linguagens/pilhas e casos de uso.
Sobre o app
O aplicativo (código, sob a licença MIT) que você vai bifurcar é um aplicativo PHP 5.7 básico com autenticação do MySQL. A ideia principal do app é oferecer uma plataforma em que os usuários possam fazer upload de fotos e os administradores possam marcar imagens inadequadas. O aplicativo tem duas tabelas:
- Usuários. Vem pré-compilado com administradores. Novas pessoas podem se registrar.
- Images Vem com algumas imagens de exemplo. Os usuários conectados podem fazer upload de novas fotos. Vamos adicionar um pouco de mágica aqui.
Sua meta
Queremos modernizar o aplicativo antigo para que ele seja executado no Google Cloud. Vamos usar as ferramentas e os serviços dele para melhorar a escalonabilidade, aumentar a segurança, automatizar o gerenciamento da infraestrutura e integrar recursos avançados, como processamento de imagens, monitoramento e repositório de dados, usando serviços como Cloud SQL, Cloud Run, Cloud Build, Secret Manager e muito mais.

Mais importante ainda, queremos fazer isso passo a passo para que você aprenda o processo de pensamento por trás de cada etapa. Geralmente, cada etapa abre novas possibilidades para as próximas (por exemplo: módulos 2 -> 3 e 6 -> 7).
Ainda não se convenceu? Confira este vídeo de 7 minutos no YouTube.
O que é necessário
- Um computador com um navegador, conectado à Internet.
- Alguns créditos do GCP. Consulte a próxima etapa para saber como fazer isso.
- Você vai usar o Cloud Shell. Ele vem com todos os comandos pré-instalados que você vai precisar e um ambiente de desenvolvimento integrado.
- Conta do GitHub. Você precisa disso para ramificar o código original 🧑🏻💻 gdgpescara/app-mod-workshop com seu próprio repositório Git. Isso é necessário para ter seu próprio pipeline de CI/CD (commit automático -> build -> implantação)
Exemplos de soluções podem ser encontrados aqui:
- O repositório do autor: https://github.com/Friends-of-Ricc/app-mod-workshop
- O repositório original do workshop, nas pastas
.solutions/, por capítulo.
Este workshop foi projetado para ser concluído no Cloud Shell (em um navegador).
No entanto, também é possível tentar fazer isso no seu computador local.
2. Configuração de crédito e bifurcação

Resgatar o crédito do GCP e configurar o ambiente do GCP [opcional]
Para realizar este workshop, você precisa de uma conta de faturamento com algum crédito. Use os créditos do banner na parte de cima deste codelab para começar. Se você já estiver conectado a uma conta de faturamento, pule esta etapa.
Depois, abra o console do Google Cloud e crie um novo projeto clicando no seletor de projetos no menu suspenso no canto superior esquerdo, onde aparece "Nenhuma organização". Consulte abaixo

Crie um projeto se ainda não tiver um, conforme mostrado na captura de tela abaixo. Há uma opção "NOVO PROJETO" no canto superior direito.

Vincule o novo projeto à conta de faturamento de teste do GCP da seguinte maneira.

Tudo pronto para você usar o Google Cloud Platform. Se você é iniciante ou quer fazer tudo em um ambiente do Cloud, acesse o Cloud Shell e o editor dele pelo botão no canto superior esquerdo, conforme mostrado abaixo.

Verifique se o novo projeto está selecionado no canto superior esquerdo:
Não selecionado (ruim):

Selecionado (bom):

Bifurcar o app do GitHub
- Acesse o app de demonstração: https://github.com/gdgpescara/app-mod-workshop
- Clique em 🍴 Fork.
- Se você não tiver uma conta do GitHub, crie uma.
- Edite o que quiser.

- Clone o código do app usando
git clonehttps://github.com/YOUR-GITHUB-USER/YOUR-REPO-NAME
- Abra a pasta do projeto clonado com seu editor favorito. Se você escolher o Cloud Shell, clique em Abrir editor, conforme mostrado abaixo.

Você tem tudo o que precisa com o editor do Google Cloud Shell, como mostra a figura a seguir

Para fazer isso visualmente, clique em "Abrir pasta" e selecione a pasta, provavelmente app-mod-workshop na sua pasta inicial.
3. Módulo 1: criar uma instância do SQL
Criar a instância do Google Cloud SQL
Nosso app PHP vai se conectar a um banco de dados MySQL. Por isso, precisamos replicá-lo no Google Cloud para uma migração sem problemas. O Cloud SQL é a combinação perfeita, porque permite executar um banco de dados MySQL totalmente gerenciado no Cloud. Siga estas etapas:
- Acesse a página do Cloud SQL: https://console.cloud.google.com/sql/instances
- Clique em "Criar instância".
- Ative a API (se necessário). Isso pode demorar alguns segundos…
- Escolha MySQL.
- (Estamos tentando conseguir a versão mais barata para que dure mais):
- Edição: Enterprise
- Predefinição: desenvolvimento (tentamos o Sandbox, mas não funcionou para nós)
- Versão do MySQL: 5.7 (uau, uma viagem no tempo!)
- ID da instância: escolha
appmod-phpapp(se você mudar isso, lembre-se de mudar também os scripts e as soluções futuras). - Senha: o que você quiser, mas anote como CLOUDSQL_INSTANCE_PASSWORD
- Região: mantenha a mesma que você escolheu para o restante do app (por exemplo, Milão =
europe-west8) - Disponibilidade por zona: Zona única (estamos economizando dinheiro para a demonstração)
Clique no botão "Criar instância" para implantar o banco de dados do Cloud SQL. ⌛ Isso leva cerca de 10 minutos⌛. Enquanto isso, continue lendo a documentação. Você também pode começar a resolver o próximo módulo ("Colocar seu app PHP em contêiner"), já que ele não tem dependências neste módulo na primeira parte (até que você corrija a conexão do banco de dados).
Observação: Essa instância deve custar cerca de US$ 7 por dia. Não se esqueça de desativá-lo após o workshop.
Criar o banco de dados image_catalog e o usuário no Cloud SQL
O projeto do app vem com uma pasta db/ que contém dois arquivos SQL:
- 01_schema.sql: contém o código SQL para criar duas tabelas com dados de usuários e imagens.
- 02_seed.sql: contém o código SQL para propagar dados nas tabelas criadas anteriormente.
Esses arquivos serão usados mais tarde, quando o banco de dados image_catalog for criado. Para isso, siga estas etapas:
- Abra sua instância e clique na guia "Bancos de dados":
- clique em "Criar banco de dados"
- chame-o de
image_catalog(como na configuração do app PHP).

Em seguida, criamos o usuário do banco de dados. Com isso, podemos autenticar no banco de dados image_catalog.
- Agora clique na guia Usuários.
- Clique em "Adicionar conta de usuário".
- Usuário: vamos criar um:
- Nome de usuário:
appmod-phpapp-user - Senha: escolha algo que você consiga lembrar ou clique em "Gerar".
- Mantenha Permitir qualquer host (%).
- clique em ADICIONAR.
Abra o banco de dados para IPs conhecidos.
Todos os bancos de dados no Cloud SQL são criados "isolados". É preciso configurar explicitamente uma rede para que ela seja acessível.
- Clique na sua instância.
- Abra o menu "Conexões".
- Clique na guia "Rede".
- Clique em "Redes autorizadas". Agora adicione uma rede (ou seja, uma sub-rede).
- Por enquanto, vamos escolher uma configuração rápida, mas INSEGURA, para que o app funcione. Depois, você pode restringir o acesso aos IPs em que confia:
- Nome: "Everyone in the world - INSECURE".
- Rede: "
0.0.0.0/0"(Observação: esta é a parte INSEGURA!) - Clique em CONCLUÍDO
- Clique em "Salvar".
Você verá algo como:

Observação: Essa solução é um bom compromisso para concluir o workshop em O(horas). No entanto, confira o documento SECURITY para ajudar a proteger sua solução para produção.
Hora de testar a conexão com o banco de dados.
Vamos ver se o usuário image_catalog que criamos antes funciona.
Acesse o "Cloud SQL Studio" dentro da instância e insira o banco de dados, o usuário e a senha para autenticação, conforme mostrado abaixo:

Agora que você está dentro, abra o editor de SQL e prossiga para a próxima seção.
Importar o banco de dados da base de código
Use o editor SQL para importar as tabelas image_catalog com os dados delas. Copie o código SQL dos arquivos no repositório (01_schema.sql e depois 02_seed.sql) e execute-os um após o outro em ordem sequencial.
Depois disso, você vai ter duas tabelas no image_catalog, que são users e images, como mostrado abaixo:

Para testar, execute o seguinte no editor: select * from images;
Anote também o endereço IP público da instância do Cloud SQL, porque você vai precisar dele mais tarde. Para encontrar o IP, acesse a página principal da instância do Cloud SQL em Visão geral. (Visão geral > Conectar-se a esta instância > Endereço IP público).
4. Módulo 2: conteinerizar o app PHP

Queremos criar esse app para a nuvem.
Isso significa empacotar o código em um arquivo ZIP que contém todas as informações para executá-lo na nuvem.
Há algumas maneiras de empacotar:
- Docker Muito popular, mas bastante complexo de configurar corretamente.
- Buildpacks. Menos popular, mas tende a "adivinhar automaticamente" o que criar e o que executar. Muitas vezes, isso é o suficiente.
No contexto deste workshop, vamos presumir que você usa o Docker.
Se você escolheu usar o Cloud Shell, reabra-o agora (clique no canto superior direito do console do Cloud).

Isso vai abrir um shell na parte de baixo da página, onde você deve ter bifurcado o código na etapa de configuração.

Docker
Se você quiser ter controle, essa é a solução certa para você. Isso faz sentido quando você precisa configurar bibliotecas específicas e injetar determinados comportamentos não óbvios (um chmod em uploads, um executável não padrão no app etc.).
Como queremos implantar nosso aplicativo conteinerizado no Cloud Run, consulte a seguinte documentação. Como você faria o backport do PHP 8 para o PHP 5.7? Talvez você possa usar o Gemini para isso. Como alternativa, use esta versão pré-criada:
# Use the official PHP image: https://hub.docker.com/_/php
FROM php:5.6-apache
# Configure PHP for Cloud Run.
# Precompile PHP code with opcache.
# Install PHP's extension for MySQL
RUN docker-php-ext-install -j "$(nproc)" opcache mysqli pdo pdo_mysql && docker-php-ext-enable pdo_mysql
RUN set -ex; \
{ \
echo "; Cloud Run enforces memory & timeouts"; \
echo "memory_limit = -1"; \
echo "max_execution_time = 0"; \
echo "; File upload at Cloud Run network limit"; \
echo "upload_max_filesize = 32M"; \
echo "post_max_size = 32M"; \
echo "; Configure Opcache for Containers"; \
echo "opcache.enable = On"; \
echo "opcache.validate_timestamps = Off"; \
echo "; Configure Opcache Memory (Application-specific)"; \
echo "opcache.memory_consumption = 32"; \
} > "$PHP_INI_DIR/conf.d/cloud-run.ini"
# Copy in custom code from the host machine.
WORKDIR /var/www/html
COPY . .
# Setup the PORT environment variable in Apache configuration files: https://cloud.google.com/run/docs/reference/container-contract#port
ENV PORT=8080
# Tell Apache to use 8080 instead of 80.
RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf
# Note: This is quite insecure and opens security breaches. See last chapter for hardening ideas.
# Uncomment at your own risk:
#RUN chmod 777 /var/www/html/uploads/
# Configure PHP for development.
# Switch to the production php.ini for production operations.
# RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
# https://github.com/docker-library/docs/blob/master/php/README.md#configuration
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"
# Expose the port
EXPOSE 8080
A versão mais recente do Dockerfile está disponível neste link.
Para testar o aplicativo localmente, precisamos alterar o arquivo config.php para que o app PHP se conecte ao banco de dados MYSQL disponível no Google Cloud SQL. Com base no que você configurou antes, preencha os espaços em branco:
<?php
// Database configuration
$db_host = '____________';
$db_name = '____________';
$db_user = '____________';
$db_pass = '____________';
try {
$pdo = new PDO("mysql:host=$db_host;dbname=$db_name", $db_user, $db_pass);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
die("Errore di connessione: " . $e->getMessage());
}
session_start();
?>
DB_HOSTé o endereço IP público do Cloud SQL, que pode ser encontrado no console do SQL:

DB_NAMEnão deve ser alterado:image_catalogDB_USERprecisa serappmod-phpapp-userDB_PASSé algo que você escolheu. Configure-o entre aspas simples e use caracteres de escape conforme necessário.
Além disso, fique à vontade para traduzir as poucas partes em italiano 🇮🇹 para o inglês com a ajuda do Gemini!
Agora que você tem o Dockerfile e configurou o app PHP para se conectar ao banco de dados, vamos testar.
Instale o Docker se ainda não tiver feito isso (link). Você não precisa disso se estiver usando o Cloud Shell (legal, né?).
Agora tente criar e executar o app PHP conteinerizado com os comandos docker build e run apropriados.
# Build command - don't forget the final . This works if Dockerfile is inside the code folder:
$ docker build -t my-php-app-docker .
# Local Run command: most likely ports will be 8080:8080
$ docker run -it -p <CONTAINER_PORT>:<LOCAL_MACHINE_PORT> my-php-app-docker
Se tudo estiver funcionando, você verá a seguinte página da Web ao se conectar ao host local. Agora que o app está em execução na porta 8080, clique no ícone "Visualização na Web" (um navegador com um olho) e em Visualizar na porta 8080 (ou "Alterar porta" para qualquer outra porta).

Como testar o resultado no navegador
Agora, o aplicativo vai ficar assim:

Se você fizer login com Admin/admin123, vai aparecer algo assim.

Ótimo! Além do texto em italiano, está funcionando! 🎉🎉🎉
Se a dockerização estiver correta, mas as credenciais do banco de dados estiverem erradas, você poderá receber algo como:

Tente de novo, você está perto!
Como salvar no Artifact Registry [opcional]
Agora você já deve ter um aplicativo PHP conteinerizado pronto para ser implantado na nuvem. Em seguida, precisamos de um lugar na nuvem para armazenar nossa imagem Docker e disponibilizá-la para implantação em serviços do Google Cloud, como o Cloud Run. Essa solução de armazenamento é chamada de Artifact Registry, um serviço totalmente gerenciado do Google Cloud projetado para armazenar artefatos de aplicativos, incluindo imagens de contêiner do Docker, pacotes Maven, módulos npm e muito mais.
Vamos criar um repositório no Artifact Registry do Google Cloud usando o botão apropriado.

Escolha um nome válido, o formato e a região adequada para armazenar os artefatos.

Volte para o ambiente de desenvolvimento local, marque e envie a imagem do contêiner do aplicativo para o repositório do Artifact Registry que você acabou de criar. Para fazer isso, execute os comandos a seguir.
- docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
- docker push TARGET_IMAGE[:TAG]
O resultado será semelhante à captura de tela abaixo.

Oba 🎉🎉🎉 você pode passar para o próximo nível. Antes disso, talvez seja bom passar dois minutos tentando fazer upload/login/logout e se familiarizando com os endpoints do app.Você vai precisar deles mais tarde.
Possíveis erros
Se você receber erros de conteinerização, use o Gemini para explicar e corrigir o erro, fornecendo:
- Seu Dockerfile atual
- O erro recebido
- [se necessário] o código PHP que está sendo executado.
Permissões de upload. Teste também o endpoint /upload.php e tente fazer upload de uma imagem. Talvez você receba o erro abaixo. Se sim, você precisa corrigir o chmod/chown no Dockerfile.
Warning: move_uploaded_file(uploads/image (3).png): failed to open stream: Permission denied in /var/www/html/upload.php on line 11
PDOException "could not find driver" (ou "Errore di connessione: could not find driver"). Verifique se o Dockerfile tem as bibliotecas PDO adequadas para o mysql (pdo_mysql) para se conectar ao banco de dados. Inspire-se com as soluções neste link.
Não foi possível encaminhar sua solicitação para um back-end. Não conseguimos conexão com um servidor na porta 8080. Isso significa que você provavelmente está expondo a porta errada. Verifique se você está expondo a porta que o Apache/Nginx está usando. Isso não é trivial. Se possível, use a porta 8080 (facilita a vida com o Cloud Run). Se você quiser manter a porta 80 (por exemplo, porque o Apache exige isso), use um comando diferente para executá-lo:
$ docker run -it -p 8080:80 # force 80
# Use the PORT environment variable in Apache configuration files.
# https://cloud.google.com/run/docs/reference/container-contract#port
RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf
5. Módulo 3: implantar o app no Cloud Run

Por que o Cloud Run?
Boa pergunta! Anos atrás, você certamente teria escolhido o Google App Engine.
Em resumo, hoje o Cloud Run tem uma pilha de tecnologia mais recente, é mais fácil de implantar, mais barato e reduz a escala vertical para 0 quando não está em uso. Com a flexibilidade de executar qualquer contêiner sem estado e a integração com vários serviços do Google Cloud, ele é ideal para implantar microsserviços e aplicativos modernos com o mínimo de sobrecarga e o máximo de eficiência.
Mais especificamente, o Cloud Run é uma plataforma totalmente gerenciada pelo Google Cloud que permite executar aplicativos conteinerizados sem estado em um ambiente sem servidor. Ele lida automaticamente com toda a infraestrutura, escalonando do zero para atender ao tráfego recebido e reduzindo quando ocioso, o que o torna econômico e eficiente. O Cloud Run é compatível com qualquer linguagem ou biblioteca, desde que esteja empacotada em um contêiner, o que permite grande flexibilidade no desenvolvimento. Ele se integra bem a outros serviços do Google Cloud e é adequado para criar microsserviços, APIs, sites e aplicativos orientados a eventos sem precisar gerenciar a infraestrutura do servidor.
Pré-requisitos
Para realizar essa tarefa, você precisa ter o gcloud instalado na sua máquina local. Caso contrário, consulte as instruções neste link. Se você estiver no Google Cloud Shell, não será necessário fazer nada.
Antes de implantar…
Se você estiver trabalhando no ambiente local, autentique-se no Google Cloud com o seguinte comando:
$ gcloud auth login –update-adc # not needed in Cloud Shell
Isso vai autenticar você por um login do OAuth no navegador. Faça login no Chrome com o mesmo usuário (por exemplo, vattelapesca@gmail.com) que está conectado ao Google Cloud com o faturamento ativado.
Ative a API Cloud Run com o seguinte comando:
$ gcloud services enable run.googleapis.com cloudbuild.googleapis.com
Agora, tudo está pronto para implantação no Cloud Run.
Implantar o app no Cloud Run usando a gcloud
O comando que permite implantar o app no Cloud Run é gcloud run deploy. Há várias opções para definir e alcançar sua meta. O conjunto mínimo de opções (que podem ser fornecidas pela linha de comando ou que a ferramenta vai solicitar com um comando interativo) é o seguinte:
- Nome do serviço do Cloud Run que você quer implantar para o app. Um serviço do Cloud Run vai retornar um URL que fornece um endpoint para o app.
- Região do Google Cloud em que o app será executado. (
--regionREGION) - Imagem do contêiner que envolve o app.
- Variáveis de ambiente que o app precisa usar durante a execução.
- A flag Allow-Unauthenticated, que permite que todos acessem seu app sem autenticação adicional.
Consulte a documentação (ou role para baixo para ver uma possível solução) para saber como aplicar essa opção à linha de comando.
A implantação vai levar alguns minutos. Se tudo estiver correto, você verá algo assim no console do Google Cloud.


Clique no URL fornecido pelo Cloud Run e teste o aplicativo. Depois da autenticação, você vai ver algo assim.

"gcloud run deploy" sem argumentos
Você deve ter percebido que o gcloud run deploy faz as perguntas certas e preenche as lacunas que você deixou. Que máximo!
No entanto, em alguns módulos, vamos adicionar esse comando a um gatilho de build do Cloud Build, então não podemos ter perguntas interativas. Precisamos preencher todas as opções no comando. Você quer criar o gcloud run deploy --option1 blah --foo bar --region your-fav-region dourado. Como fazer isso?
- repita as etapas 2, 3 e 4 até que a gcloud pare de fazer perguntas:
- [LOOP]
gcloud run deploycom opções encontradas até agora - [LOOP] os sistemas pedem a opção X
- [LOOP] Pesquise na documentação pública como configurar X na CLI adicionando a opção
--my-option [my-value]. - Volte para a etapa 2, a menos que a gcloud seja concluída sem mais perguntas.
- Esse gcloud run deploy BLAH BLAH BLAH é demais! Salve o comando em algum lugar, porque você vai precisar dele mais tarde para a etapa do Cloud Build.
Uma solução possível está aqui. A documentação está aqui.
Pronto 🎉🎉🎉 Você implantou seu app no Google Cloud, concluindo a primeira etapa da modernização.
6. Módulo 4: limpar a senha com o Secret Manager

Na etapa anterior, conseguimos implantar e executar nosso app no Cloud Run. No entanto, fizemos isso com uma prática de segurança ruim: fornecer alguns secrets em texto não criptografado.
Primeira iteração: atualize o config.php para usar ENV
Talvez você tenha notado que colocamos a senha do banco de dados diretamente no código do arquivo config.php. Isso é bom para fins de teste e para ver se o app funciona. Mas não é possível confirmar/usar um código como esse em um ambiente de produção. A senha (e outros parâmetros de conexão do banco de dados) precisa ser lida dinamicamente e fornecida ao app no momento da execução. Altere o arquivo config.php para que ele leia os parâmetros do banco de dados das variáveis de ambiente. Se falhar, considere definir valores padrão. Isso é bom caso você não consiga carregar o ENV, para que a saída da página informe se os valores padrão estão sendo usados. Preencha os espaços em branco e substitua o código no config.php.
<?php
// Database configuration with ENV variables. Set default values as well
$db_host = getenv('DB_HOST') ?: 'localhost';
$db_name = getenv('DB_NAME') ?: 'image_catalog';
$db_user = getenv('DB_USER') ?: 'appmod-phpapp-user';
$db_pass = getenv('DB_PASS') ?: 'wrong_password';
// Note getenv() is PHP 5.3 compatible
try {
$pdo = new PDO("mysql:host=$db_host;dbname=$db_name", $db_user, $db_pass);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
die("Errore di connessione: " . $e->getMessage());
}
session_start();
?>
Como o app é conteinerizado, você precisa fornecer uma maneira de fornecer as variáveis de ambiente ao app. Isso pode ser feito de algumas maneiras:
- No momento do build, no Dockerfile. Adicione ao Dockerfile anterior os quatro parâmetros usando a sintaxe ENV DB_VAR=ENV_VAR_VALUE. Isso vai configurar valores padrão que podem ser substituídos no ambiente de execução. Por exemplo, "DB_NAME" e "DB_USER" podem ser definidos aqui e em nenhum outro lugar.
- No ambiente de execução. É possível configurar essas variáveis para o Cloud Run na CLI ou na interface. Esse é o lugar certo para colocar todas as quatro variáveis, a menos que você queira manter os padrões definidos no Dockerfile.
No localhost, talvez você queira colocar as variáveis ENV em um arquivo .env (verifique a pasta solutions).
Verifique também se .env foi adicionado ao .gitignore : você não quer enviar seus secrets para o GitHub.
echo .env >> .gitignore
Depois, teste a instância localmente:
docker run -it -p 8080:8080 --env-file .env my-php-app-docker
Agora você já fez o seguinte:
- Seu app vai ler a variável dinamicamente do seu ENV
- Você melhorou a segurança ao remover a senha do banco de dados do código.
Agora é possível implantar uma nova revisão no Cloud Run. Vamos acessar a interface e definir as variáveis de ambiente manualmente:
- Acesse https://console.cloud.google.com/run.
- Clique no seu aplicativo.
- Clique em "Editar e implantar uma nova revisão".
- Na primeira guia "Contêineres", clique na guia inferior "Variáveis e secrets".
- Clique em "+ Adicionar variável" e adicione todas as variáveis necessárias. O resultado será parecido com este:


Isso é perfeito? Não. Seu PASS ainda está visível para a maioria dos operadores. Isso pode ser mitigado com o Secret Manager do Google Cloud.
Segunda iteração: Secret Manager
Suas senhas desapareceram do seu próprio código: vitória! Mas espere: já estamos seguros?
Suas senhas ainda estão visíveis para qualquer pessoa que tenha acesso ao console do Google Cloud. Na verdade, se você acessar o arquivo YAML de implantação do Cloud Run, poderá recuperá-lo. Ou, se você tentar editar ou implantar uma nova revisão do Cloud Run, a senha vai ficar visível na seção "Variáveis e secrets", conforme mostrado nas capturas de tela abaixo.
O Secret Manager do Google Cloud é um serviço seguro e centralizado para gerenciar informações sensíveis, como chaves de API, senhas, certificados e outros secrets.
Ele permite armazenar, gerenciar e acessar secrets com permissões refinadas e criptografia robusta. Integrado ao Identity and Access Management (IAM) do Google Cloud, o Secret Manager permite controlar quem pode acessar secrets específicos, garantindo a segurança de dados e a conformidade regulatória.
Ele também oferece suporte à rotação e ao controle de versões automáticos de secrets, simplificando o gerenciamento do ciclo de vida de secrets e aumentando a segurança em aplicativos nos serviços do Google Cloud.
Para acessar o Secret Manager, navegue no menu de navegação até os serviços de Segurança e encontre-o na seção Proteção de dados, conforme mostrado na captura de tela abaixo.

Ative a API Secret Manager, conforme mostrado na imagem a seguir.

- Agora clique em "Criar um secret" e dê um nome racional a ele:
- Nome:
php-amarcord-db-pass - Valor do secret: "sua senha do banco de dados" (ignore a parte "fazer upload do arquivo").
- anote este link secreto, que deve ser semelhante a
projects/123456789012/secrets/php-amarcord-db-pass. Este é o ponteiro exclusivo para seu secret (para Terraform, Cloud Run e outros). O número é o número exclusivo do projeto.
Dica: tente usar convenções de nomenclatura consistentes para seus secrets, especializando da esquerda para a direita, por exemplo: cloud-devrel-phpamarcord-dbpass
- Organização (com a empresa)
- Equipe (na organização)
- Aplicativo (na equipe)
- Nome da variável (no app)
Isso permite que você tenha regexes fáceis para encontrar todas as suas chaves secretas de um único app.
Criar uma nova revisão do Cloud Run
Agora que temos um novo Secret, precisamos nos livrar da variável de ambiente DB_PASS e substituí-la pelo novo Secret. Então:
- Acesso ao Cloud Run usando o console do Google Cloud
- Escolha o app.
- Clique em "Editar e implantar uma nova revisão".
- localize a guia "Variáveis e secrets".
- Use o botão "+ Referenciar um secret" para redefinir a variável de ambiente DB_PASS.
- Use o mesmo "DB_PASS" para os Secrets referenciados e use a versão mais recente.

Depois disso, você vai receber o seguinte erro:

Tente descobrir como corrigir o problema. Para resolver isso, acesse a seção IAM e administrador e mude as permissões de concessão. Boa depuração!
Depois de descobrir, volte ao Cloud Run e reimplante uma nova revisão. O resultado será semelhante à figura a seguir:

Dica: o Console do Desenvolvedor (interface) é ótimo para apontar problemas de permissão. Aproveite para navegar por todos os links das suas entidades do Cloud.
7. Módulo 5: configurar a CI/CD com o Cloud Build

Por que usar um pipeline de CI/CD?
Até agora, você já deve ter digitado gcloud run deploy algumas vezes, talvez respondendo à mesma pergunta repetidamente.
Cansou de implantar seu app manualmente com o comando gcloud run deploy? Não seria ótimo se o app pudesse ser implantado automaticamente sempre que você enviasse uma nova mudança para o repositório Git?
Para usar um pipeline de CI/CD, você precisa de duas coisas:
- Um repositório Git pessoal: você já deve ter bifurcado o repositório do workshop para sua conta do GitHub na Etapa 2. Se não, volte e conclua essa etapa. Seu repositório bifurcado vai ficar assim:
https://github.com/<YOUR_GITHUB_USER>/app-mod-workshop - Cloud Build. Esse serviço incrível e barato permite configurar automações de build para praticamente tudo: Terraform, apps dockerizados, ..
Esta seção vai se concentrar na configuração do Cloud Build.
Conheça o Cloud Build!
Vamos usar o Cloud Build para fazer isso:
- criar sua origem (com o Dockerfile). Pense nisso como um "arquivo .zip grande" que contém tudo o que você precisa para criar e executar o aplicativo (seu "artefato de build").
- enviar esse artefato para o Artifact Registry (AR).
- Em seguida, emita uma implantação do AR para o Cloud Run para o app "php-amarcord"
- Isso vai criar uma nova versão ("revisão") do app atual (pense em uma camada com o novo código), e vamos configurá-la para desviar o tráfego para a nova versão se o push for bem-sucedido.
Este é um exemplo de algumas versões do meu app php-amarcord:

Como fazemos tudo isso?
- Criando um arquivo YAML perfeito:
cloudbuild.yaml - Criando um gatilho de build do Cloud Build.
- Conectando-se ao repositório do GitHub pela interface do Cloud Build.
Criar gatilho (e conectar repositório)
- Acesse https://console.cloud.google.com/cloud-build/triggers.
- Clique em "Criar gatilho".
- Compilar:
- Nome: algo significativo, como
on-git-commit-build-php-app - Evento: enviar por push para a ramificação
- Origem: "Conectar novo repositório"

- Uma janela será aberta à direita: "Conectar repositório"
- Provedor de origem: "Github" (primeiro)
- "Continuar"
- A autenticação vai abrir uma janela no GitHub para fazer a autenticação cruzada. Siga o fluxo e tenha paciência. Se você tiver muitos repositórios, isso pode levar algum tempo.
- "Select repo" (Selecionar repositório): selecione sua conta/repositório e marque a parte "I understand..." (Eu entendo...).
- Se você receber o erro "O app GitHub não está instalado em nenhum dos seus repositórios", clique em "Instalar o Google Cloud Build" e siga as instruções.
Clique em "Conectar".
- Bingo! Seu repositório está conectado.
- Voltando à parte do gatilho…
- Configuração: detectada automaticamente (*)
- Avançado: selecione a conta de serviço "[PROJECT_NUMBER]- compute@developer.gserviceaccount.com"
- xxxxx é o ID do projeto
- A conta de serviço de computação padrão é adequada para uma abordagem de laboratório, mas não a use em produção. (Saiba mais).
- Deixe o restante como está.
- Clique no botão "Criar".
(*) Essa é a maneira mais simples, porque verifica se há um Dockerfile ou cloudbuild.yaml. No entanto, o cloudbuild.yaml oferece o poder real de decidir o que fazer em cada etapa.
Eu tenho o poder!
Agora, o gatilho não vai funcionar se você não conceder à conta de serviço do Cloud Build (o que é uma conta de serviço? O e-mail de um "robô" que age em seu nome para uma tarefa, neste caso, criar coisas na nuvem.
O SA não vai conseguir criar e implantar, a menos que você dê permissão para isso. Felizmente, é fácil!
- acesse "Cloud Build" > "Configurações".
- Conta de serviço "[PROJECT_NUMBER]- compute@developer.gserviceaccount.com"
- Marque estas caixas:
- Cloud Run
- Secret Manager
- Contas de serviço
- Cloud Build
- Marque também a opção "Definir como conta de serviço preferencial".

Onde está o YAML do Cloud Build?
Recomendamos que você dedique um tempo para criar seu próprio YAML do Cloud Build.
No entanto, se você não tiver tempo ou não quiser fazer isso, poderá se inspirar nesta pasta de soluções: .solutions.
Agora você pode enviar uma alteração para o GitHub e observar o Cloud Build fazer a parte dele.
Configurar o Cloud Build pode ser complicado. Espere algumas idas e vindas:
- Verificando registros em https://console.cloud.google.com/cloud-build/builds;region=global
- Encontrar o erro.
- Corrigir no código e emitir novamente git commit / git push.
- Às vezes, o erro não está no código, mas em alguma configuração. Nesse caso, é possível emitir um novo build na interface (Cloud Build > "Gatilhos" > Executar)

Se você usar essa solução, ainda haverá trabalho a ser feito. Por exemplo, é preciso definir as variáveis ENV para os endpoints de desenvolvimento/produção recém-criados:

Faça isso de duas maneiras:
- Pela interface: definindo as variáveis ENV novamente
- Pela CLI, criando o script "perfeito" para você. Confira um exemplo aqui: gcloud-run-deploy.sh. Você precisa ajustar algumas coisas, como o endpoint e o número do projeto, que pode ser encontrado na Visão geral do Cloud.
Como faço para confirmar o código no GitHub?
Não faz parte do escopo deste workshop ensinar a melhor maneira de fazer git push no GitHub. No entanto, se você estiver no Cloud Shell e não conseguir avançar, há duas maneiras:
- CLI. Adicione uma chave SSH localmente e um controle remoto com git@github.com:YOUR_USER/app-mod-workshop.git (em vez de http).
- VSCode. Se você usa o editor do Cloud Shell, pode usar a guia "Controle de origem" (ctrl-shift-G), clicar em "Sincronizar mudanças" e seguir as instruções. Você deve conseguir autenticar sua conta do GitHub no VS Code, e as operações de pull/push vão ficar muito mais fáceis.

Não se esqueça de git add clodubuild.yaml entre outros arquivos, ou não vai funcionar.
Paridade de desenvolvimento/produção profunda x superficial [opcional]
Se você copiou a versão do modelo daqui, terá duas versões idênticas de DEV e PROD. Isso é legal e está de acordo com a regra 10 do aplicativo de 12 fatores.
No entanto, estamos usando dois endpoints da Web diferentes para que um app aponte para o mesmo banco de dados. Isso é suficiente para um workshop, mas, na vida real, é preciso dedicar um tempo para criar um ambiente de produção adequado. Isso significa ter dois bancos de dados (um para desenvolvimento e outro para produção) e também escolher onde eles vão ficar para recuperação de desastres / alta disponibilidade. Isso está fora do escopo deste workshop, mas é algo para se pensar.
Se você tiver tempo para fazer uma versão "profunda" da produção, lembre-se de todos os recursos que precisa duplicar, como:
- Banco de dados do Cloud SQL (e provavelmente instância do SQL).
- Bucket do GCS
- Cloud Function.
- Você pode usar o Gemini 1.5 Flash como um modelo em desenvolvimento (mais barato e rápido) e o Gemini 1.5 Pro (mais potente).
Em geral, sempre que você fizer algo no app, pense de forma crítica: a produção precisa ter esse mesmo valor ou não? Se não, duplique seu esforço. Isso é muito mais fácil com o Terraform, em que é possível injetar seu ambiente (-dev, -prod) como um sufixo nos recursos.
8. Módulo 6: migrar para o Google Cloud Storage

Armazenamento

No momento, o app armazena o estado em um contêiner do Docker. Se a máquina quebrar, o app explodir ou você simplesmente enviar uma nova revisão, uma nova revisão será programada com um novo armazenamento vazio: 🙈
Como corrigir isso? Há várias abordagens.
- Armazenar imagens no banco de dados. Foi o que fiz com meu app PHP anterior. É a solução mais simples, porque não adiciona complexidade. Mas isso adiciona latência e carga ao seu banco de dados.
- Migrar o app do Cloud Run para uma solução compatível com armazenamento: GCE + disco permanente? Talvez GKE + Storage? Observação: o que você ganha em controle, perde em agilidade.
- Mova para o GCS. O Google Cloud Storage oferece o melhor armazenamento para todo o Google Cloud e é a solução mais idiomática do Cloud. No entanto, é preciso usar as bibliotecas PHP. Temos bibliotecas PHP 5.7 para o GCS? O
PHP 5.7é compatível com oComposer? Parece que o PHP 5.3.2 é a versão mais antiga compatível com o Composer. - Talvez usar um sidecar do Docker?
- Ou use as montagens de volume do Cloud Run do GCS. Isso parece incrível.
🤔 Migrar armazenamento (resposta aberta)
[Resposta aberta] Neste exercício, queremos que você encontre uma solução para mover suas imagens de uma forma que seja persistente.
Teste de aceitação
Não quero dizer a solução, mas quero que isso aconteça:
- Você faz upload de
newpic.jpg. Você vai ver isso no app. - Você faz upgrade do app para uma nova versão.
newpic.jpgainda está lá, visível.
💡 Solução possível (montagens de volume do Cloud Run do GCS)
Essa é uma solução muito elegante que permite fazer uploads de arquivos com estado sem tocar no código (além de mostrar uma descrição de imagem, mas isso é trivial e apenas para satisfação visual).
Isso permite que você monte uma pasta do Cloud Run no GCS. Portanto:
- Todos os uploads para o GCS vão ficar visíveis no app.
- Todos os uploads para o app serão feitos no GCS
- A mágica vai acontecer com os objetos enviados para o GCS (capítulo 7).
Observação: Leia as letras miúdas do FUSE. Isso NÃO é aceitável se o desempenho for um problema.
Criar um bucket do GCS
O GCS é o serviço de armazenamento onipresente do Google Cloud. Ele é testado em batalha e usado por todos os serviços do GCP que precisam de armazenamento.
O Cloud Shell exporta PROJECT_ID como GOOGLE_CLOUD_PROJECT:
$ export PROJECT_ID=$GOOGLE_CLOUD_PROJECT
#!/bin/bash
set -euo pipefail
# Your Cloud Run Service Name, eg php-amarcord-dev
SERVICE_NAME='php-amarcord-dev'
BUCKET="${PROJECT_ID}-public-images"
GS_BUCKET="gs://${BUCKET}"
# Create bucket
gsutil mb -l "$GCP_REGION" -p "$PROJECT_ID" "$GS_BUCKET/"
# Copy original pictures there - better if you add an image of YOURS before.
gsutil cp ./uploads/*.png "$GS_BUCKET/"
Configurar o Cloud Run para montar o bucket na pasta /uploads/
Agora vamos para a parte elegante. Criamos um volume php_uploads e instruímos o Cloud Run a fazer uma montagem do FUSE em MOUNT_PATH (algo como /var/www/html/uploads/):
#!/bin/bash
set -euo pipefail
# .. keep variables from previous script..
# Uploads folder within your docker container.
# Tweak it for your app code.
MOUNT_PATH='/var/www/html/uploads/'
# Inject a volume mount to your GCS bucket in the right folder.
gcloud --project "$PROJECT_ID" beta run services update "$SERVICE_NAME" \
--region $GCP_REGION \
--execution-environment gen2 \
--add-volume=name=php_uploads,type=cloud-storage,bucket="$BUCKET" \
--add-volume-mount=volume=php_uploads,mount-path="$MOUNT_PATH"
Agora, repita essa etapa para todos os endpoints que você quer apontar para o Cloud Storage.
Também é possível fazer o mesmo na interface
- Na guia "Volumes", crie pontos de montagem de volume que apontem para seu bucket, do tipo "bucket do Cloud Storage", por exemplo, com o nome "php_uploads".
- Em Contêineres > Montagens de volume, monte o volume que você acabou de criar no ponto de volume solicitado pelo app. Isso depende do Dockerfile, mas pode ser semelhante a
var/www/html/uploads/.
De qualquer forma, se funcionar, a edição da nova revisão do Cloud Run vai mostrar algo assim:

Agora teste o novo aplicativo fazendo upload de uma nova imagem para o endpoint /upload.php.
As imagens devem fluir perfeitamente no GCS sem escrever uma única linha de PHP:

O que aconteceu?
Algo muito mágico aconteceu.
Um aplicativo antigo com código antigo ainda está funcionando. Uma pilha nova e modernizada permite que todas as imagens/fotos do nosso app fiquem em um bucket com estado do Cloud. Agora o céu é o limite:
- Quer enviar um e-mail sempre que uma imagem com "perigoso" ou "nudez" for recebida? Você pode fazer isso sem mexer no código PHP.
- Quer usar um modelo multimodal do Gemini para descrever cada imagem que chega e fazer upload do banco de dados com a descrição? Você pode fazer isso sem tocar no código PHP. Você não acredita em mim? Continue lendo no capítulo 7.
Acabamos de abrir um grande espaço de oportunidade aqui.
9. Módulo 7: Turbinar seu app com o Google Gemini

Agora você tem um app PHP moderno e brilhante (como um Fiat 126 de 2024) com armazenamento em nuvem.
O que você pode fazer com ele?
Pré-requisitos
No capítulo anterior, uma solução de modelo permitiu que montássemos imagens /uploads/ no GCS, separando de fato a lógica do app do armazenamento de imagens.
Neste exercício, você vai:
- Concluiu o exercício do capítulo 6 (armazenamento).
- Ter um bucket do GCS com os uploads de imagens, em que as pessoas fazem upload de fotos no seu app e as fotos vão para o bucket.
Configurar uma função do Cloud (em Python)
Você já se perguntou como implementar um aplicativo orientado a eventos? Algo como:
- quando <evento> acontecer => enviar um e-mail
- quando <event> acontecer => se <condition> for verdadeira, atualize o banco de dados.
Um evento pode ser qualquer coisa, desde um novo registro disponível no BigQuery, um novo objeto alterado em uma pasta no GCS ou uma nova mensagem aguardando em uma fila no Pub/Sub.
O Google Cloud oferece suporte a vários paradigmas para isso. Em especial:
- EventArc. Saiba como receber eventos do GCS. Ótimo para criar DAGs e organizar ações com base em if-then-else no Cloud.
- Cloud Scheduler. Ótimo para um cron job à meia-noite na nuvem, por exemplo.
- Cloud Workflows. Assim como o Eventarc, permite
- Cloud Run Functions (conhecido como
lambdas). - Cloud Composer: Basicamente, é a versão do Google do Apache Airflow, também excelente para DAG.
Neste exercício, vamos nos aprofundar no Cloud Functions para alcançar um resultado espetacular. E vamos oferecer exercícios opcionais para você.
O exemplo de código é fornecido em .solutions/.
Configurar uma função do Cloud (🐍 Python)
Estamos tentando criar uma GCF muito ambiciosa.
- Quando uma nova imagem é criada no GCS… (provavelmente porque alguém o enviou no app, mas não só por isso)
- .. chamar o Gemini para descrevê-la e receber uma descrição textual da imagem .. (seria bom verificar o MIME e garantir que seja uma imagem, não um PDF, MP3 ou texto)
- … e atualizar o banco de dados com essa descrição. (isso pode exigir a aplicação de patch no banco de dados para adicionar uma coluna
descriptionà tabelaimages).
Aplique um patch ao banco de dados para adicionar description às imagens
- Abra o Cloud SQL Studio:

- Insira seu usuário e senha do banco de dados de imagens.
- Insira este SQL, que adiciona uma coluna para uma descrição de imagem:
ALTER TABLE images ADD COLUMN description TEXT;

E bingo! Tente agora para verificar se funcionou:
SELECT * FROM images;
A nova coluna de descrição vai aparecer:

Escreva a função f(x) do Gemini
Observação: Essa função foi criada com a ajuda do Gemini Code Assist.
Observação: Ao criar essa função, você pode receber erros de permissão do IAM. Alguns estão documentados abaixo no parágrafo "Possíveis erros".
- Ative as APIs
- Acesse https://console.cloud.google.com/functions/list.
- Clique em "Criar função"
- Ative as APIs no assistente de APIs:

É possível criar o GCF na interface ou na linha de comando. Aqui, vamos usar a linha de comando.
Um código possível pode ser encontrado em .solutions/
- Crie uma pasta para hospedar seu código, por exemplo, "gcf/". Acesse a pasta.
- Crie um arquivo
requirements.txt:
google-cloud-storage
google-cloud-aiplatform
pymysql
- Crie uma função em Python. Exemplo de código aqui: gcf/main.py.
#!/usr/bin/env python
"""Complete this"""
from google.cloud import storage
from google.cloud import aiplatform
import vertexai
from vertexai.generative_models import GenerativeModel, Part
import os
import pymysql
import pymysql.cursors
# Replace with your project ID
PROJECT_ID = "your-project-id"
GEMINI_MODEL = "gemini-1.5-pro-002"
DEFAULT_PROMPT = "Generate a caption for this image: "
def gemini_describe_image_from_gcs(gcs_url, image_prompt=DEFAULT_PROMPT):
pass
def update_db_with_description(image_filename, caption, db_user, db_pass, db_host, db_name):
pass
def generate_caption(event, context):
"""
Cloud Function triggered by a GCS event.
Args:
event (dict): The dictionary with data specific to this type of event.
context (google.cloud.functions.Context): The context parameter contains
event metadata such as event ID
and timestamp.
"""
pass
- Envie a função. Use um script semelhante a este: gcf/push-to-gcf.sh.
Observação 1. Não se esqueça de definir as variáveis de ambiente com os valores certos ou apenas adicioná-las no topo (GS_BUCKET=blah, ..):
Observação 2. Isso vai enviar todo o código local (.). Portanto, coloque seu código em uma pasta específica e use o .gcloudignore como um profissional para evitar o envio de bibliotecas enormes. (exemplo).
#!/bin/bash
set -euo pipefail
# add your logic here, for instance:
source .env || exit 2
echo "Pushing ☁️ f(x)☁ to 🪣 $GS_BUCKET, along with DB config.. (DB_PASS=$DB_PASS)"
gcloud --project "$PROJECT_ID" functions deploy php_amarcord_generate_caption \
--runtime python310 \
--region "$GCP_REGION" \
--trigger-event google.cloud.storage.object.v1.finalized \
--trigger-resource "$BUCKET" \
--set-env-vars "DB_HOST=$DB_HOST,DB_NAME=$DB_NAME,DB_PASS=$DB_PASS,DB_USER=$DB_USER" \
--source . \
--entry-point generate_caption \
--gen2
Observação: neste exemplo, generate_caption será o método invocado, e a função do Cloud vai transmitir o evento do GCS para ele com todas as informações relevantes (nome do bucket, nome do objeto etc.). Reserve um tempo para depurar esse dicionário Python de eventos.
Como testar a função
Testes de unidade
A função tem muitas partes móveis. Talvez você queira testar todos os casos individuais.
Um exemplo está em gcf/test.py.
Interface do Cloud Functions
Aproveite também para conhecer sua função na interface. Vale a pena explorar todas as guias, principalmente Source (minha favorita), Variables, Trigger e Logs. Você vai passar muito tempo em Logs para resolver erros (consulte também os possíveis erros na parte de baixo desta página). Além disso, confira Permissions.

Teste E2E
Hora de testar a função manualmente.
- Acesse o app e faça login.
- Faça upload de uma imagem (não muito grande, já tivemos problemas com imagens grandes)
- verifique na interface se a imagem foi enviada.
- No Cloud SQL Studio, verifique se a descrição foi atualizada. Faça login e execute esta consulta:
SELECT * FROM images.

E funciona. Também podemos atualizar o front-end para mostrar essa descrição.
Atualizar o PHP para mostrar [opcional]
Provamos que o app funciona. No entanto, seria bom que os usuários também pudessem ver essa descrição.
Não precisamos ser especialistas em PHP para adicionar a descrição ao index.php. Este código deve fazer o seguinte (sim, o Gemini também escreveu isso para mim!):
<?php if (!empty($image['description'])): ?>
<p class="font-bold">Gemini Caption:</p>
<p class="italic"><?php echo $image['description']; ?></p>
<?php endif; ?>
Posicione esse código dentro de foreach como preferir.
Nas próximas etapas, também vamos ver uma versão mais bonita da interface, graças ao Gemini Code Assist. Uma versão mais bonita seria assim:

Conclusões
Você tem uma função do Cloud acionada em novos objetos que chegam ao GCS, que pode anotar o conteúdo da imagem como um ser humano faria e atualizar automaticamente o banco de dados. Uau!
A seguir Você pode seguir o mesmo raciocínio para alcançar duas ótimas funcionalidades.
[opcional] Adicionar mais funções do Cloud Functions [resposta aberta]
Alguns recursos adicionais vêm à mente.
📩 Acionador de e-mail
Um gatilho de e-mail que envia um e-mail para você sempre que alguém envia uma foto.
- Com muita frequência? Adicione outra restrição: uma imagem GRANDE ou uma imagem em que o conteúdo do Gemini contenha as palavras "nude/nudity/violent".
- Considere verificar
EventArcpara isso.
🚫 Moderação automática de fotos inadequadas
Atualmente, um administrador humano está sinalizando imagens como "inapropriadas". Que tal deixar o Gemini fazer o trabalho pesado e moderar o espaço? Adicione um teste para sinalizar conteúdo de gatilho inadequado e atualizar o banco de dados, como aprendemos na função anterior. Isso significa basicamente pegar a função anterior, mudar o comando e atualizar o banco de dados com base na resposta.
Aviso. A IA generativa tem saídas imprevisíveis. Verifique se a "resposta criativa" do Gemini está "nos trilhos". Você pode pedir uma resposta determinista, como uma pontuação de confiança de 0 a 1, um JSON etc. Isso pode ser feito de várias maneiras, por exemplo: * Usando bibliotecas Python pydantic, langchain etc. * Usando a saída estruturada do Gemini.
Dica. Você pode ter VÁRIAS funções ou um único comando que impõe uma resposta JSON (funciona muito bem com a "Saída estruturada do Gemini", como destacado acima), como:
Qual seria o comando para gerar isso?
{
"description": "This is the picture of an arrosticino",
"suitable": TRUE
}
Você pode adicionar campos extras ao comando para receber insights como: há algo de bom nisso? Ruim? Você reconhece o lugar? Há algum texto (o OCR nunca foi tão fácil):
goods: "Parece uma comida gostosa"bads: "Parece comida que não é saudável"OCR: "Da consumare preferibilmente prima del 10 Novembre 2024"location: "Pescara, Lungomare"
Embora geralmente seja melhor ter uma função N para resultados N, é incrivelmente gratificante fazer uma que faça 10 coisas. Confira este artigo de Riccardo para saber como.
Possíveis erros (principalmente IAM / permissões)
Na primeira vez que desenvolvi essa solução, tive alguns problemas de permissão do IAM. Vou adicioná-los aqui para empatia e para dar algumas ideias de como corrigi-los.
Erro: permissões insuficientes para a conta de serviço
- Para implantar uma função do GCF que detecta um bucket do GCS, é preciso configurar as permissões adequadas para a conta de serviço que você está usando no job, como na figura:

Talvez você também precise ativar as APIs do Eventarc. Aguarde alguns minutos até que elas fiquem totalmente disponíveis.
Erro: invocador do Cloud Run ausente
- Outro comentário da interface para permissões do GCF é este (papel de invocador do Cloud Run):

Para corrigir esse erro, execute o comando na imagem, que é semelhante a fix-permissions.sh.
Esse problema é descrito aqui: https://cloud.google.com/functions/docs/securing/authenticating
Erro: limite de memória excedido
Na primeira vez que o executei, meus registros poderiam dizer: "Limite de memória de 244 MiB excedido com 270 MiB usados. Considere aumentar o limite de memória. Consulte https://cloud.google.com/functions/docs/configuring/memory'". Adicione RAM à GCF. Isso é muito fácil de fazer na interface. Veja um possível aumento:

Como alternativa, você também pode corrigir o script de implantação do Cloud Run para aumentar a memória/CPU. Isso leva um pouco mais de tempo.
Erro: Pub/Sub publicado
A criação de um gatilho com o GCF v1 resultou neste erro:

Para corrigir isso, basta acessar o IAM e atribuir o papel "Publicador do Pub/Sub" à conta de serviço.
Erro: a Vertex AI não foi usada
Se você receber este erro:
Permissão negada: a API Vertex AI 403 não foi usada no projeto YOUR_PROJECT ou está desativada. Para ativá-la, acesse https://console.developers.google.com/apis/api/aiplatform.googleapis.com/overview?project=YOR_PROJECT
Basta ativar as APIs da Vertex AI. A maneira mais fácil de ativar TODAS as APIs necessárias é esta:
- https://console.cloud.google.com/vertex-ai
- Clique em "Ativar todas as APIs recomendadas".

Erro: gatilho do Eventarc não encontrado.
Se isso acontecer, reimplante a função.

Erro: 400 agentes de serviço estão sendo provisionados
400 Service agents are being provisioned ( https://cloud.google.com/vertex-ai/docs/general/access-control#service-agents ). Service agents are needed to read the Cloud Storage file provided. Tente de novo em alguns minutos.
Se isso acontecer, aguarde um pouco ou peça ajuda a um Googler.
10. Módulo 8: Criar SLOs de disponibilidade
Neste capítulo, tentamos alcançar o seguinte:
- Como criar SLIs
- Como criar SLOs com base nos SLIs
- Como criar alertas com base em SLOs

Esse é um assunto muito importante para o autor, já que Riccardo trabalha na área de SRE/DevOps do Google Cloud.
(resposta aberta) Criar SLIs e SLOs para este app
De que adianta um app se você não sabe quando ele está inativo?
O que é um SLO?
Ah! O Google inventou os SLOs. Para saber mais sobre o assunto, sugiro:
- Livro sobre SRE - capítulo 2 - Como implementar SLOs. ( 👉 mais livros sobre SRE)
- Art of SLOs (vídeo incrível). É um treinamento fantástico para aprender a criar um SLO perfeito para seu serviço.
- Curso de SRE no Coursera. Eu contribuí para isso!
Etapa 1: criar o SLI/SLO de disponibilidade
Vamos começar com o SLO de disponibilidade, já que é o mais fácil e possivelmente o mais importante que você quer medir.
Felizmente, o Cloud Run vem com suporte pré-criado para SLOs, graças ao Istio.
Depois que o app estiver no Cloud Run, isso é muito simples de fazer, leva 30 segundos.
- Acesse a página do Cloud Run.
- Clique/selecione seu app.
- Selecione a guia
SLOs. - Clique em "+ Criar SLO".
- Disponibilidade, com base em solicitações
- Continuar
- Mês no calendário / 99%.
- clique em "Criar SLO".

Etapa 2: configurar alertas para esse SLO
Sugiro criar dois alertas:
- Um com uma taxa de consumo baixa ("Slowburn") para alertar você por e-mail (simula um tíquete de baixa prioridade).
- Um com uma alta taxa de consumo ("Fastburn") para alertar você por SMS (simula um ticket / pager de alta prioridade)
Acesse o SLO tab de antes.
Faça isso duas vezes:

- Clique em "Criar alerta de SLO" (o botão 🔔 com um sinal de adição dentro, à direita).
- Duração do lookback, limite do índice de desempenho de custo:
- [FAST]. Primeiro:
60min /10x - [LENTO]. Segunda:
720min /2x - Canal de notificação: clique em "Gerenciar canais de notificação".
- Primeiro, "E-mail" -> Adicionar novo -> ..
- Em seguida, "SMS" -> Adicionar novo -> Verificar no smartphone.
- Dica: gosto de usar emojis nos nomes. É divertido para demonstrações.
- Quando terminar, clique no X grande no canto superior direito.
- Selecione primeiro o telefone (rápido) e depois o e-mail (lento).
- Adicione uma documentação de amostra, como:
[PHP Amarcord] Riccardo told me to type sudo reboot or to check documentation in http://example.com/playbooks/1.php but I guess he was joking.
Bingo!
Resultado final
Podemos considerar este exercício concluído quando você tiver 1 SLO em funcionamento + 2 alertas para sua disponibilidade, e ele estiver enviando alertas para seu e-mail e telefone.
Se quiser, adicione uma latência (e eu recomendo que você faça isso) ou até mesmo uma mais complexa. Para latência, escolha uma que você considere razoável. Em caso de dúvida, escolha 200 ms.
11. Próximas etapas
Você concluiu TUDO, o que está faltando?
Algumas reflexões:
Curta com o Gemini
Você pode usar o Gemini de duas maneiras:
- Vertex AI. O "modo empresarial", integrado ao GCP, que analisamos no capítulo 7 (GCF+Gemini). Toda a autenticação funciona como mágica, e os serviços se interconectam perfeitamente.
- IA do Google. O "modo do consumidor". Você recebe uma chave de API Gemini aqui e começa a criar pequenos scripts que podem ser vinculados a qualquer carga de trabalho que você já tenha (trabalho proprietário, outras nuvens, localhost etc.). Basta substituir sua chave de API e o código começa a funcionar como mágica.
Incentivamos você a testar o (2) com seus próprios projetos de estimação.
UI Lifting
Não sou bom com interfaces. Mas o Gemini é! Você pode pegar uma única página PHP e dizer algo como:
I have a VERY old PHP application. I want to touch it as little as possible. Can you help me:
1. add some nice CSS to it, a single static include for tailwind or similar, whatever you prefer
2. Transform the image print with description into cards, which fit 4 per line in the canvas?
Here's the code:
-----------------------------------
[Paste your PHP page, for instance index.php - mind the token limit!]
Você pode fazer isso em menos de 5 minutos, com apenas um Cloud Build. :)
A resposta do Gemini foi perfeita (ou seja, não precisei mudar nada):

E este é o novo layout no app pessoal do autor:

Observação: o código é colado como imagem porque não queremos incentivar você a copiar o código, mas sim fazer com que o Gemini escreva o código para você, com suas próprias restrições criativas de interface/front-end. Confie em mim, você vai precisar fazer apenas pequenas mudanças depois.
Segurança
Proteger adequadamente esse app não é uma meta deste workshop de 4 horas, porque isso aumentaria o tempo de conclusão em 1 ou 2 ordens de magnitude.
No entanto, esse assunto é muito importante. Reunimos algumas ideias em SECURITY.
12. Parabéns!
Parabéns 🎉🎉🎉 , você modernizou seu aplicativo PHP legado com o Google Cloud.

Em resumo, você aprendeu neste codelab:
- Como implantar um banco de dados no Google Cloud SQL e como migrar seu banco de dados atual para ele.
- Como conteinerizar seu aplicativo PHP com o Docker e os Buildpacks e armazenar a imagem dele no Artifact Registry do Google Cloud
- Como implantar seu app conteinerizado no Cloud Run e executá-lo com o Cloud SQL
- Como armazenar/usar secretamente parâmetros de configuração sensíveis (como senha do banco de dados) usando o Google Secret Manager
- Como configurar seu pipeline de CI/CD com o Google Cloud Build para criar e implantar automaticamente seu app PHP em qualquer push de código para o repositório do GitHub.
- Como usar o Cloud Storage para "cloudificar" os recursos do seu app
- Como usar tecnologias sem servidor para criar fluxos de trabalho incríveis no Google Cloud sem tocar no código do app.
- Usar os recursos multimodais do Gemini para um caso de uso adequado.
- Implementar princípios de SRE no Google Cloud
Este é um ótimo começo para sua jornada de modernização de aplicativos com o Google Cloud.
🔁 Feedback
Se quiser nos contar sobre sua experiência com este workshop, preencha este formulário de feedback.
Queremos saber sua opinião e receber solicitações de envio para partes do código de que você se orgulha.
🙏 Valeu
O autor gostaria de agradecer a Mirko Gilioli e Maurizio Ipsale da Datatonic pela ajuda na redação e no teste da solução.
