Workshop de modernização de apps

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:

  1. Conteinerizar o aplicativo PHP.
  2. Migrar para um serviço de banco de dados gerenciado (Cloud SQL).
  3. Implantar no Cloud Run (uma alternativa sem operações ao GKE/Kubernetes).
  4. Proteger o aplicativo com o Identity and Access Management (IAM) e o Secret Manager.
  5. 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.
  6. Hospedar as imagens do aplicativo no Cloud Storage. Isso é feito por meio da montagem, e nenhum código é necessário para mudar o app.
  7. Introduzir a funcionalidade de IA generativa com o Gemini, orquestrada pelo Cloud Functions (sem servidor).
  8. 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.

445f7a9ae37e9b4d.png

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:

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

6dafc658860c0ce5.png

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

bd7548f78689db0b.png

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.

6c82aebcb9f5cd47.png

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

f202527d254893fb.png

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.

7d732d7bf0deb12e.png

Verifique se o novo projeto está selecionado no canto superior esquerdo:

Não selecionado (ruim):

c2ffd36a781b276a.png

Selecionado (bom):

594563c158f4f590.png

Bifurcar o app do GitHub

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

734e51bfc29ee5df.png

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

40f5977ea4c1d1cb.png

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

a4e5ffb3e9a35e84.png

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

645902e511a432a6.png

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:

  1. Acesse a página do Cloud SQL: https://console.cloud.google.com/sql/instances
  2. Clique em "Criar instância".
  3. Ative a API (se necessário). Isso pode demorar alguns segundos…
  4. Escolha MySQL.
  5. (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!)
  1. ID da instância: escolha appmod-phpapp (se você mudar isso, lembre-se de mudar também os scripts e as soluções futuras).
  2. Senha: o que você quiser, mas anote como CLOUDSQL_INSTANCE_PASSWORD
  3. Região: mantenha a mesma que você escolheu para o restante do app (por exemplo, Milão = europe-west8)
  4. 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:

  1. 01_schema.sql: contém o código SQL para criar duas tabelas com dados de usuários e imagens.
  2. 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:

  1. Abra sua instância e clique na guia "Bancos de dados":
  2. clique em "Criar banco de dados"
  3. chame-o de image_catalog (como na configuração do app PHP).

997ef853e5ebd857.png

Em seguida, criamos o usuário do banco de dados. Com isso, podemos autenticar no banco de dados image_catalog.

  1. Agora clique na guia Usuários.
  2. Clique em "Adicionar conta de usuário".
  3. 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 (%).
  1. 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.

  1. Clique na sua instância.
  2. Abra o menu "Conexões".
  3. Clique na guia "Rede".
  4. 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
  1. Clique em "Salvar".

Você verá algo como:

5ccb9062a7071964.png

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:

d56765c6154c11a4.png

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:

65ba01e4c6c2dac0.png

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

e7f0e9979d8805f5.png

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

ec6a6b90b39e03e.png

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.

6999b906c0dedeb7.png

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:

bd27071bf450a8d0.png

  • DB_NAME não deve ser alterado: image_catalog
  • DB_USER precisa ser appmod-phpapp-user
  • DB_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).

33a24673f4550454.png

Como testar o resultado no navegador

Agora, o aplicativo vai ficar assim:

2718ece96b1f18b6.png

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

68b62048c2e86aea.png

Ó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:

e22f45b79bab86e1.png

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.

e1123f0c924022e6.png

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

4e516ed209c470ee.png

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.

1e498feb4e88be9f.png

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

9ffca42774f6c5d1.png

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:

  1. 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.
  2. Região do Google Cloud em que o app será executado. (--region REGION)
  3. Imagem do contêiner que envolve o app.
  4. Variáveis de ambiente que o app precisa usar durante a execução.
  5. 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.

ef1029fb62f8de81.pngf7191d579c21ca3e.png

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

d571a90cd5a373f9.png

"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?

  1. repita as etapas 2, 3 e 4 até que a gcloud pare de fazer perguntas:
  2. [LOOP] gcloud run deploy com opções encontradas até agora
  3. [LOOP] os sistemas pedem a opção X
  4. [LOOP] Pesquise na documentação pública como configurar X na CLI adicionando a opção --my-option [my-value].
  5. Volte para a etapa 2, a menos que a gcloud seja concluída sem mais perguntas.
  6. 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

95cd57b03b4e3c73.png

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:

  1. Seu app vai ler a variável dinamicamente do seu ENV
  2. 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:

7a5fbfa448544d3.pngf2780c35585388ca.png

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.

6df83a1c3cb757f6.png

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

a96c312e2c098db1.png

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

9ed4e35be7654dcb.png

Depois disso, você vai receber o seguinte erro:

da0ccd7af39b04ed.png

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:

e89f9ca780169b6b.png

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

ba49b033c11be94c.png

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:

  1. 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
  2. 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:

f30f42d4571ad5e2.png

Como fazemos tudo isso?

  1. Criando um arquivo YAML perfeito: cloudbuild.yaml
  2. Criando um gatilho de build do Cloud Build.
  3. 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" texto alternativo
  • 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.
  • 23e0e0f1219afea3.pngClique em "Conectar".
  • bafd904ec07122d2.png
  • 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".

8715acca72286a46.png

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)

97acd16980a144ab.png

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:

3da8723e4ff80c0a.png

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:

  1. CLI. Adicione uma chave SSH localmente e um controle remoto com git@github.com:YOUR_USER/app-mod-workshop.git (em vez de http).
  2. 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.

f0d53f839c7fa3b6.png

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

a680e0f287dd2dfb.png

Armazenamento

dc3a4b8ea92aaef6.png

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.

  1. 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.
  2. 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.
  3. 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 o Composer? Parece que o PHP 5.3.2 é a versão mais antiga compatível com o Composer.
  4. Talvez usar um sidecar do Docker?
  5. 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:

  1. Você faz upload de newpic.jpg. Você vai ver isso no app.
  2. Você faz upgrade do app para uma nova versão.
  3. newpic.jpg ainda 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:

  1. Todos os uploads para o GCS vão ficar visíveis no app.
  2. Todos os uploads para o app serão feitos no GCS
  3. 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

  1. 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".
  2. 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:

6c2bb98fc1b0e077.png

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:

70032b216afee2d7.png

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

c00425f0ad83b32c.png

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:

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.

  1. Quando uma nova imagem é criada no GCS… (provavelmente porque alguém o enviou no app, mas não só por isso)
  2. .. 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)
  3. … 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 à tabela images).

Aplique um patch ao banco de dados para adicionar description às imagens

  1. Abra o Cloud SQL Studio:

b92b07c4cba658ef.png

  1. Insira seu usuário e senha do banco de dados de imagens.
  2. Insira este SQL, que adiciona uma coluna para uma descrição de imagem:

ALTER TABLE images ADD COLUMN description TEXT;

3691aced78a6389.png

E bingo! Tente agora para verificar se funcionou:

SELECT * FROM images;

A nova coluna de descrição vai aparecer:

bed69d6ad0263114.png

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

  1. Ative as APIs
  2. Acesse https://console.cloud.google.com/functions/list.
  3. Clique em "Criar função"
  4. Ative as APIs no assistente de APIs:

d22b82658cfd4c48.png

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

  1. Crie uma pasta para hospedar seu código, por exemplo, "gcf/". Acesse a pasta.
  2. Crie um arquivo requirements.txt:
google-cloud-storage
google-cloud-aiplatform
pymysql
  1. 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
  1. 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.

cf3ded30d532a2c7.png

Teste E2E

Hora de testar a função manualmente.

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

43a680b12dbbdda0.png

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:

fdc12de0c88c4464.png

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 EventArc para 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

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

22f51012fa6b4a24.png

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

  1. Outro comentário da interface para permissões do GCF é este (papel de invocador do Cloud Run):

be72e17294f2d3f3.png

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:

bed69d6ad0263114.png

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:

e5c338ee35ad4c24.png

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:

  1. https://console.cloud.google.com/vertex-ai
  2. Clique em "Ativar todas as APIs recomendadas".

492f05ac377f3630.png

Erro: gatilho do Eventarc não encontrado.

Se isso acontecer, reimplante a função.

8ec4fc11833d7420.png

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:

  1. Como criar SLIs
  2. Como criar SLOs com base nos SLIs
  3. Como criar alertas com base em SLOs

f63426182c052123.png

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:

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

e471c7ebdc56cdf6.png

Etapa 2: configurar alertas para esse SLO

Sugiro criar dois alertas:

  1. Um com uma taxa de consumo baixa ("Slowburn") para alertar você por e-mail (simula um tíquete de baixa prioridade).
  2. 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:

314bfd6b9ef0a260.png

  • 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: 60 min / 10 x
  • [LENTO]. Segunda: 720 min / 2 x
  • 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:

  1. 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.
  2. 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):

8a3d5fe37ec40bf8.png

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

81620eb90ae3229a.png

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.

24cb9a39b1841fbd.png

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.