Python: Usos avançados

Avançar com as suas implementações Python

👋 Bem-vindo à documentação do Stackhero!

Stackhero oferece uma solução cloud Python pronta a usar que proporciona uma série de benefícios, incluindo:

  • Implemente a sua aplicação em segundos com um simples git push.
  • Utilize o seu próprio nome de domínio e beneficie da configuração automática de certificados HTTPS para uma segurança reforçada.
  • Desfrute de tranquilidade com backups automáticos, atualizações com um clique, e preços simples, transparentes e previsíveis.
  • Obtenha performance ótima e segurança robusta graças a uma VM privada e dedicada.

Poupe tempo e simplifique a sua vida: só leva 5 minutos para experimentar a solução de hospedagem cloud Python do Stackhero!

Implementar um ramo diferente de main

Até agora, utilizámos o comando git push stackhero main para implementar o ramo main em produção.

Se precisar de implementar um ramo diferente, pode usar este comando onde <BRANCH> é o nome do ramo que deseja implementar:

git push stackhero <BRANCH>:main

Por exemplo, se quiser implementar o ramo production, basta executar:

git push stackhero production:main

Implementar uma tag em vez de um ramo

Pode optar por implementar uma tag em vez de um ramo. Para implementar uma tag específica, substitua <TAG> pela tag desejada no comando abaixo:

git push stackhero '<TAG>^{}:main'

Por exemplo, para implementar a tag v1.0.0, executaria:

git push stackhero 'v1.0.0^{}:main'

A sintaxe ^{} garante que está a enviar o commit marcado em vez da referência da tag em si.

Implementar um commit específico

Além de implementar ramos ou tags, também pode implementar um commit específico usando o seu hash. Substitua <COMMIT_HASH> pelo hash do commit que deseja implementar:

git push -f stackhero <COMMIT_HASH>:main

Por exemplo, para implementar o commit com o hash abcde, execute:

git push -f stackhero abcde:main

Reverter para uma versão anterior

Se uma implementação recente introduziu problemas, pode reverter para um commit anterior implementando esse commit. Primeiro, identifique o hash do commit executando:

git log

Este comando exibe a data, o hash e a descrição de cada commit.

Por exemplo, a saída pode ser assim:

git log

commit cccc8b3ebdccb9abc1926ef49ee589dae5c5fe06 (HEAD -> main, stackhero/main)
Author: Developer
Date:   Fri Apr 28 09:36:18 +0000

    Break the code

commit bbbb622301772072c3d82f3cc0d91e29e6e84901
Author: Developer
Date:   Wed Apr 26 12:49:28 +0000

    Update the code

commit aaaa1d8b06535b413e0df8298ccf52339dfef3ff
Author: Developer
Date:   Wed Apr 26 12:44:50 +0000

    Improve the code

Se a implementação atual em produção for o commit "Break the code" (hash começando com cccc), e desejar reverter para o commit anterior "Update the code" (hash começando com bbbb), execute:

git push -f stackhero bbbb622301772072c3d82f3cc0d91e29e6e84901:main

Para evitar implementar código com erros e aumentar a estabilidade da sua produção, é altamente recomendável ter um ambiente de "staging".

Situado entre o desenvolvimento e a produção, o ambiente de staging fornece uma réplica próxima da configuração de produção. Ajuda a testar o seu código de forma completa antes de uma implementação ao vivo.

Utilizar o staging aumenta a sua confiança na funcionalidade e desempenho do seu código, resultando numa implementação em produção mais robusta.

Este tipo de ambiente será discutido mais tarde na documentação.

Configurar um ambiente de staging

Um ambiente de staging é uma boa prática quando usado juntamente com os ambientes de desenvolvimento e produção. Replica o ambiente de produção para que possa testar atualizações e alterações antes de ir ao vivo, reduzindo o risco de problemas em produção.

Um ambiente de staging deve refletir de perto o ambiente de produção.

No entanto, deve usar uma versão clonada da sua base de dados de produção ou serviços conectados em vez da base de dados de produção ao vivo.

Se o seu serviço Python depender de bases de dados ou outros serviços, recrie-os num novo stack <Project> - Staging.

Siga estes passos para configurar um ambiente de staging com Stackhero:

  1. No painel de controlo Stackhero, renomeie o seu stack existente de <Project> para <Project> - Production. Por exemplo, se o seu projeto se chamar Chat Bot, o stack torna-se Chat Bot - Production.
  2. Crie um novo stack chamado <Project> - Staging. Para o projeto Chat Bot, o stack torna-se Chat Bot - Staging.
  3. Inicie um serviço Python dentro do stack de staging.
  4. Recupere o comando git remote e siga as instruções na documentação Implementar no ambiente de staging.

Esta configuração garante que tem um ambiente de staging totalmente funcional para testar atualizações antes da implementação em produção.

Implementar no ambiente de staging

É altamente recomendável manter ambientes de staging e produção separados. Para gerir múltiplos ambientes, comece por renomear o repositório remoto atual. Por exemplo, renomeie o remoto stackhero para stackhero-production com:

git remote rename stackhero stackhero-production

Em seguida, crie um novo serviço Python para o seu ambiente de staging. Recupere o comando git remote add e modifique-o substituindo <XXXXXX> pelo domínio do seu serviço:

  • Comando original:

    git remote add stackhero ssh://stackhero@<XXXXXX>.stackhero-network.com:222/project.git

  • Comando modificado:

    git remote add stackhero-staging ssh://stackhero@<XXXXXX>.stackhero-network.com:222/project.git

Pode então implementar em qualquer ambiente usando os seguintes comandos:

  • Implementar no staging:

    git push stackhero-staging main

  • Implementar em produção:

    git push stackhero-production main

Para melhorar o processo de implementação, sugerimos utilizar a versão melhorada do Makefile.

Com este Makefile melhorado, implementar em produção ou staging torna-se tão simples quanto executar make deploy-production ou make deploy-staging.

Versão melhorada do Makefile

Abaixo está um Makefile melhorado que suporta múltiplas regras:

  • make dev (ou simplesmente make): Inicia a aplicação em modo de desenvolvimento.
  • make deploy: Implementa a aplicação no remoto chamado stackhero. Isto funciona bem quando tem uma única instância Stackhero.
  • make deploy-production: Implementa a aplicação no remoto chamado stackhero-production.
  • make deploy-staging: Implementa a aplicação no remoto chamado stackhero-staging.

Este Makefile é projetado para lidar com situações onde o código não mudou, evitando o erro "Everything up-to-date".

Copie e cole o seguinte conteúdo como o seu novo Makefile:

# Regra a executar por padrão ao invocar "make" sem argumento
.DEFAULT_GOAL := dev


# Stackhero para Python executará a regra "run" na sua instância.
# Este é o comando a executar nos seus ambientes de produção e staging.
run:
  ENV=production gunicorn app:app \
    --error-logfile - \
    -b 0.0.0.0:8080


# O comando a usar no ambiente de desenvolvimento
dev:
  python app.py


# Regra "deploy" para implementar na instância "stackhero".
# Adequado se tiver apenas uma instância.
deploy:
  @$(MAKE) -s deploy-script DEPLOY_REMOTE=stackhero DEPLOY_BRANCH=main


# As regras "deploy-*" implementam numa instância chamada "stackhero-*".
# Por exemplo, executar "make deploy-production" implementa em "stackhero-production",
# ou "make deploy-staging" implementa em "stackhero-staging".
deploy-%:
  @$(MAKE) -s deploy-script DEPLOY_REMOTE=stackhero-$* DEPLOY_BRANCH=main


# Regra de implementação interna. Não a modifique.
deploy-script:
  @echo "Implementando o ramo \"${DEPLOY_BRANCH}\" para \"${DEPLOY_REMOTE}\"..."
  @echo

  @if [ -n "$$(git status --porcelain)" ]; then \
    echo "Não é possível implementar porque há alterações não confirmadas:"; \
    echo "\e[0m"; \
    git status -s; \
    echo ""; \
    echo "\e[0;31m"; \
    echo "Pode usar este comando para confirmar as alterações:"; \
    echo "git add -A . && git commit -m \"Sua mensagem\""; \
    echo "\e[0m"; \
    exit 1; \
  fi

  @git push --dry-run ${DEPLOY_REMOTE} ${DEPLOY_BRANCH} 2>&1 | grep -q -F "Everything up-to-date"; \
  EXIT_CODE=$$?; \
  if [ $$EXIT_CODE -eq 0 ]; then \
    echo -n "Nada novo para implementar... Forçar implementação (isto criará um novo commit)? (y/N) "; \
    read answer && \
    case $$answer in \
      y|Y|yes|YES) \
      git commit --allow-empty -m "Force update for deploy purpose to \"${DEPLOY_REMOTE}\"" ; \
      ;; \
    *) \
      echo "Nada para implementar!"; \
      exit 1; \
      ;; \
    esac \
  fi

  git push ${DEPLOY_REMOTE} ${DEPLOY_BRANCH}

Gestão de segredos (variáveis de ambiente)

Em algum momento, precisará armazenar segredos como tokens e senhas para bases de dados ou serviços de terceiros. É importante armazená-los de forma segura. Evite incorporá-los diretamente no seu repositório ou código, pois isso cria um risco significativo de segurança.

Usar variáveis de ambiente oferece dois benefícios principais:

  1. Os seus segredos nunca são armazenados no seu repositório Git, reduzindo o risco de acesso não autorizado.
  2. Pode usar credenciais diferentes para vários ambientes, como usar uma base de dados de produção em produção e uma base de dados de desenvolvimento durante o desenvolvimento.

Configurar variáveis de ambiente para desenvolvimento

Num ambiente de desenvolvimento, crie um ficheiro .env na raiz do seu projeto. Este ficheiro deve ser excluído do Git para garantir que nunca seja confirmado.

Para ler automaticamente o ficheiro .env, pode usar o módulo python-dotenv:

pip install python-dotenv
pip freeze > requirements.txt

Depois, crie um ficheiro .env na raiz do seu projeto e adicione as suas variáveis:

ENV="development"
DATABASE_PASSWORD="secretPassword"
THIRD_API_PRIVATE_KEY="secretKey"
# ...

Finalmente, certifique-se de que o ficheiro .env está excluído do Git adicionando-o ao seu .gitignore:

echo ".env" >> .gitignore

Configurar variáveis de ambiente para staging e produção

O ficheiro .env não é suficientemente seguro para ambientes de staging e produção. Em vez disso, o Stackhero permite que armazene com segurança as suas variáveis de ambiente diretamente na configuração do seu serviço Python.

Pode definir estas variáveis no painel de controlo Stackhero selecionando o seu serviço Python e clicando no botão "Configurar".

Variáveis de ambiente Python no StackheroVariáveis de ambiente Python no Stackhero

Aceder a variáveis de ambiente em Python

Aceder a variáveis de ambiente em Python é simples. Basta usar os.environ.get() como mostrado abaixo:

import os

print(os.environ.get('ENV'))

Por exemplo, conectar-se a um servidor Redis usando uma variável de ambiente pode ser feito assim:

import os
import redis

r = redis.from_url(os.environ.get("REDIS_URL"))

Num ambiente de desenvolvimento, defina o REDIS_URL no seu ficheiro .env da seguinte forma:

REDIS_URL="redis://localhost:6379"

Para produção e staging, defina o REDIS_URL no painel de controlo Stackhero sob a configuração do serviço Python:

REDIS_URL="rediss://default:<yourPassword>@<XXXXXX>.stackhero-network.com:6380"

Gestão de pacotes Python

É uma boa prática gerir pacotes Python usando um ficheiro requirements.txt. Este ficheiro lista todos os pacotes necessários e as suas versões para executar o seu código de forma confiável.

Manter este ficheiro atualizado garante:

  1. Todos os pacotes necessários estão instalados.
  2. Apenas versões de pacotes compatíveis são usadas.

Ao implementar na sua instância Stackhero, os pacotes especificados em requirements.txt são automaticamente instalados.

Para gerar ou atualizar requirements.txt, execute o seguinte comando após instalar novos pacotes:

pip freeze > requirements.txt

Abrir portas UDP/TCP

A maioria das aplicações Python usa as portas HTTP 80 (HTTP) e 443 (HTTPS).

Se a sua aplicação precisar abrir portas adicionais ou usar outros protocolos (TCP ou UDP), pode ajustar a configuração "Ports Redirections" no seu serviço Python no painel de controlo Stackhero.

Para cada porta adicional, especifique a porta de entrada (pública), a porta de destino (usada pela sua aplicação Python) e o protocolo (TCP ou UDP).

Redirecionamentos de portas no painel de controlo StackheroRedirecionamentos de portas no painel de controlo Stackhero

Armazenamento de ficheiros

Para armazenar ficheiros como fotos de utilizadores ou documentos, geralmente é melhor usar uma solução de armazenamento de objetos.

O armazenamento de objetos permite partilhar ficheiros entre vários serviços ou instâncias e separa o seu armazenamento do seu código, seguindo as melhores práticas.

Recomendamos MinIO, uma solução rápida e poderosa compatível com o protocolo Amazon S3.

Se preferir armazenamento de ficheiros local, pode usar o armazenamento persistente fornecido com a sua instância Python localizado em /persistent/storage/. No entanto, esta abordagem não é recomendada na maioria dos casos.

AVISO: Nunca armazene dados fora da pasta /persistent/storage/!

Armazenar dados fora desta pasta pode levar à perda de dados quando a sua instância é reiniciada, atualizada ou quando envia novo código.

Apple/macOS: guardar a senha da sua chave privada SSH

No macOS, pode ser inconveniente digitar a senha da sua chave privada SSH cada vez que envia o seu código. Embora a segurança seja primordial, pode guardar a sua senha de forma segura usando o Keychain da Apple em vez de a remover da sua chave.

Para armazenar a senha de uma chave chamada id_ed25519, execute:

ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Depois disso, não será solicitado a inserir a senha da sua chave, poupando tempo e esforço.

Se usar uma chave RSA em vez disso, substitua id_ed25519 por id_rsa no comando:

ssh-add --apple-use-keychain ~/.ssh/id_rsa

Other articles for Python