segunda-feira, 21 de outubro de 2024

Automação do Deploy da Aplicação com GitHub Actions


Fala pessoal, tudo certo?

Dando sequência, agora vamos providenciar um processo de automação de deploy da nossa aplicação de gerenciamento de tasks com o GitHub Action e também com o Render.

O que é o Render?

Render é uma plataforma de nuvem que simplifica o processo de implantação e gerenciamento de aplicações. Ele oferece uma ampla gama de serviços, como:

  • Hospedagem de Aplicações Web: Permite implantar aplicações web em diversas linguagens, como Python, Node.js, Ruby, entre outras, com facilidade.

  • Deploy Automático: Render integra-se facilmente com repositórios do GitHub e GitLab, permitindo que você faça deploy automaticamente toda vez que houver um push para a branch principal.

  • Escalabilidade: A plataforma é projetada para escalar automaticamente suas aplicações, oferecendo planos de pagamento que variam de gratuito a soluções pagas, dependendo das necessidades do projeto.

  • Suporte a Servidores e Contêineres: Render suporta a execução de aplicações em contêineres Docker e também permite a criação de servidores dedicados.

  • Simplicidade e Facilidade de Uso: Com uma interface amigável e recursos de configuração simples, o Render torna o processo de implantação acessível para desenvolvedores de todos os níveis de experiência.

Em resumo, o Render é uma ótima escolha para desenvolvedores que buscam uma solução simples e eficaz para hospedar suas aplicações na nuvem, sem se preocupar com a complexidade da infraestrutura.

Outro ponto importante do Render, podemos usar para estudo sem gerar custo. =]

Antes de mais nada, você precisar criar sua conta no site do Render - https://render.com/

Depois de ter sua conta criada, vamos ao passo-a-passo.

Criando o Web Service no Render:

Agora, no site do Render, vamos criar nosso projeto / aplicação para que o WorkFlow saiba onde fazer o deploy.

Na página inicial do Render, Clique em + New - Web Service

Conecte-se ao repositório do Git onde está o projeto do gerenciamento de tarefas.

De um nome para ele, pode ser app-task-api, por exemplo.

Na tela seguinte, tera um breve resumo de configurações feitas automaticamente. Mas também teremos alguns itens que precisamos fornecer as informações.

Em Start Command, inseria o comando que o Render irá utilizar para fazer o start da aplicação:

python app.py

Em Instance Type, selecione a opção Free.

E por último, clique no botão Deploy Web Service.

Feito isso, agora vamos voltar para nossa máquina onde está o projeto propriamente dito.

Alteração no app.py

Primeiramente, precisamos adicionar a configuração abaixo no app.py para que seja possível subir IP e Porta no Deploy do Render:

if __name__ == '__main__':

app.run(host='0.0.0.0', port=10000)

Ele ficará quase no final do arquivo:

Criar o arquivo de dependência

Dentro da pasta onde está nosso projeto, vamos criar o arquivo requeriments.txt com as dependências abaixo:

Flask==2.0.2

Werkzeug==2.0.3

Depois, vamos criar o path onde irá residir o arquivo do workflow:

mkdir -p .github/workflows

Lembre-se que aqui, ainda estamos dentro da pasta do projeto.

Vamos entrar dentro deste novo diretório:

cd .github/workflows

Criar o arquivo de deploy.yml e adicionar o seguinte conteúdo:

vi deploy.yml
name: Deploy to Render

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.8'  # ou a versão que você estiver usando

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Deploy to Render
        env:
          RENDER_API_KEY: ${{ secrets.RENDER_API_KEY }}
        run: |
          curl -X POST https://api.render.com/deploy/srv-xxxxxxxx  # substitua 'srv-xxxxxxxx' pelo ID do seu serviço

** Essa informação da URL e ID do serviço, você encontra no site do Render - Dentro da estrutura do seu Web Service - Settings - Deploy hook.

Altere para o valor correspondente do seu seriço e salve o arquivo.

Fazendo o push das alterações

Depois de criar o requirements.txt, workflow e alterar o app.py, adicione e faça o commit dessas alterações:

git add requirements.txt .github/workflows/deploy.yml app.py
git commit -m "Add requirements GitHub Actions workflow and app.py update"
git push origin main
Após executar o push, podemos ver que no GitHub Actions teremos um start do WorkFlow:



No Render, dentro de Logs temos o processo de Deploy dentro da ferramenta:

Assim que o Deploy finalizar, mais acima nessa tela temos a URL para acessar e testar nossa aplicação:

Como não teremos nada ainda, o retorno ao acessar a URL deve ser esse (lembrando que precisamos colocar no final dela /api/tasks):


Agora, vamos fazer um teste direto na API.

Para isso, vamos executar o comando curl fazendo o post de um preenchimento de informação:

curl -X POST https://task-api-5rkl.onrender.com/api/tasks -H "Content-Type: application/json" -d '{"title": "Tarefa 1", "completed": false}'

Lembre-se de atualizar a URL de acordo com a da sua aplicação.

Quando acessarmos novamente a aplicação, o resultado será esse:

Com mais esse post, agora já concluímos as seguintes etapas:

  1. Criação de uma aplicação com API exposta para gerenciamento de tarefas;
  2. Utilizar um repositório com versionamento de código;
  3. Automação do processo de Deploy e Publicação da aplicação;
Abs e até a próxima. =]
:wq!

terça-feira, 15 de outubro de 2024

Versionamento de código com Git e GitHub/GitLab


Fala pessoal, tudo certo?

Agora que você já criou sua API de gerenciamento de tarefas em Flask, o próximo passo é garantir que seu código esteja versionado e armazenado de forma segura. Para isso, usaremos o Git para controle de versão e o GitHub (ou GitLab, conforme sua preferência) para hospedar nosso repositório remoto.

Massss ...

O que é Git e GitHub?

Git é um sistema de controle de versão distribuído, amplamente utilizado no desenvolvimento de software. Ele permite que você acompanhe mudanças no código, colabore com outros desenvolvedores e retorne a versões anteriores do projeto, se necessário. Cada vez que você faz uma alteração significativa no código, você pode "comitar" essas mudanças, criando um ponto no histórico do repositório que pode ser revisitado a qualquer momento.

GitHub (ou alternativas como GitLab e Bitbucket) é uma plataforma de hospedagem de repositórios Git na nuvem. Além de fornecer uma interface visual para navegar no seu código versionado, o GitHub permite colaborar com outros desenvolvedores, revisar alterações e contribuir para projetos de código aberto. Ele também facilita a integração com pipelines de CI/CD (integração e entrega contínua) para automatizar testes e deploys.

Ao combinar Git e GitHub, você obtém uma poderosa ferramenta para controlar a evolução do seu código, manter backups e colaborar eficientemente com equipes ou até mesmo contribuir com a comunidade de software aberta.

Entendido o conceito, agora vamos a prática.

1. Instalando o Git

Antes de começarmos, verifique se o Git está instalado na sua máquina:

  • MacOS/Linux: Execute git --version no terminal.
  • Windows: Se o comando não funcionar, baixe o instalador do Git aqui e siga as instruções.

2. Configurando o Git

Após instalar o Git, configure-o com suas credenciais de usuário (nome e e-mail):

git config --global user.name "Seu Nome"
git config --global user.email "seuemail@example.com"

Isso vincula suas alterações de código à sua identidade.

3. Inicializando um repositório Git

Agora, vamos inicializar o repositório Git na pasta do seu projeto. Navegue até o diretório onde está sua API e execute:

git init

Esse comando inicializa um repositório Git localmente.

4. Adicionando arquivos para controle de versão

Depois de inicializar o repositório, adicione os arquivos do projeto à área de stage (onde você prepara os arquivos para o commit):

git add .

. indica que todos os arquivos da pasta serão adicionados.

5. Criando o primeiro commit

Agora que os arquivos estão no stage, crie um commit para registrar a primeira versão do seu código:

git commit -m "Primeira versão da API de gerenciamento de tarefas"

-m permite adicionar uma mensagem descrevendo o que foi feito.

6. Criando um repositório remoto no GitHub/GitLab

Agora que você tem um repositório local, vamos conectar com um repositório remoto para armazenar o código na nuvem.

  1. Acesse GitHub ou GitLab.
  2. Crie uma conta, se ainda não tiver uma.
  3. No GitHub/GitLab, clique em New Repository (Novo Repositório).
  4. Dê um nome ao repositório, por exemplo, task-api, e clique em Create Repository.

Agora você terá um repositório remoto vazio.

7. Conectando o repositório local ao remoto

Com o repositório remoto criado, vamos conectá-lo ao repositório local. No terminal, execute:

git remote add origin https://github.com/seuusuario/task-api.git

Substitua o URL com o link para o seu repositório no GitHub/GitLab.

8. Enviando o código para o repositório remoto

Finalmente, envie seu código para o GitHub/GitLab com o comando:

git push -u origin main

9. Autenticação com Personal Access Token (PAT)

O GitHub agora exige o uso de Personal Access Tokens em vez de senhas. Siga estes passos para gerar e usar o token:

  1. Acesse GitHub Personal Access Tokens e clique em Generate new token.
  2. Escolha as permissões adequadas (como repo) e clique em Generate token.
  3. Ao fazer git push, use o seu nome de usuário do GitHub e, em vez da senha, cole o token gerado.

O código agora está no seu repositório remoto e pode ser acessado de qualquer lugar!

Como testar se está funcionando

  1. Acesse o GitHub/GitLab e verifique se os arquivos estão no seu repositório.
  2. Tente clonar o repositório em outro diretório usando:
git clone https://github.com/seuusuario/task-api.git

Bônus: Comandos úteis do Git

  • Verificar o status dos arquivos no repositório:

git status 

  • Ver o histórico de commits:

git log

  • Reverter para um commit anterior:

git checkout <commit-hash>

Agora seu código está seguro e versionado no GitHub ou GitLab. Você aprendeu como usar o Git para versionar o código e manter um backup remoto. Na próxima postagem, vamos criar uma esteira de deploy automático para sua API.

Abs e até a próxima.
:wq!

quarta-feira, 9 de outubro de 2024

Criando sua primeira API de Gerenciamento de Tarefas com Flask (Python)


Fala pessoal, tudo bem?

Neste post, vamos criar uma API simples de gerenciamento de tarefas que pode ser executada localmente em qualquer sistema operacional. Usaremos o Flask, um framework leve para Python. Ao final, você terá uma API funcional que pode servir de ideia e um começo para implementar nos seus projetos.

Pré-requisitos

  • Python instalado em sua máquina.
    • Para verificar se o Python está instalado, execute python --version no terminal.

Estrutura do projeto
Criamos uma pasta para o projeto, que conterá os arquivos da API.

Criando a API de Gerenciamento de Tarefas com Flask

1. Criar e ativar um ambiente virtual
No terminal, navegue até a pasta do projeto e execute:

python -m venv venv
source venv/bin/activate  # Para MacOS/Linux
venv\Scripts\activate     # Para Windows

2. Instalar o Flask
Com o ambiente virtual ativado, instale o Flask:

pip install Flask

3. Criar a aplicação
Crie um arquivo chamado app.py e adicione o seguinte código:

from flask import Flask, jsonify, request

app = Flask(__name__)

# Lista de tarefas (em memória)
tasks = []

@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify(tasks)

@app.route('/api/tasks', methods=['POST'])
def add_task():
    task = request.json
    tasks.append(task)
    return jsonify(task), 201

@app.route('/api/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((t for t in tasks if t.get('id') == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({'error': 'Task not found'}), 404

@app.route('/api/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    global tasks
    tasks = [t for t in tasks if t.get('id') != task_id]
    return jsonify({'result': 'Task deleted'})

if __name__ == '__main__':
    app.run(debug=True)

4. Rodar a aplicação
Execute no terminal:

python app.py

Acesse a API em http://127.0.0.1:5000/api/tasks

Como podemos ver, a aplicação ainda está vazia e sem nenhuma task criadas. Por isso ela não irá apresentar nenhum dado.



Como testar a API com cURL

Você pode usar o cURL no terminal para interagir com a API:

  • Obter a lista de tarefas:

curl -X GET http://127.0.0.1:5000/api/tasks


  • Adicionar uma nova tarefa:

curl -X POST http://127.0.0.1:5000/api/tasks -H "Content-Type: application/json" -d '{"id": 1, "task": "Learn Flask"}'


  • Atualizar uma tarefa existente:

curl -X PUT http://127.0.0.1:5000/api/tasks/1 -H "Content-Type: application/json" -d '{"task": "Learn Flask with more features"}'


  • Deletar uma tarefa:

curl -X DELETE http://127.0.0.1:5000/api/tasks/1


Neste post, você aprendeu a criar uma API de gerenciamento de tarefas usando Flask. Também viu como testar a API usando cURL. Na próxima postagem, vamos abordar como versionar esse código utilizando Git e GitHub/GitLab. 

Se tiver alguma dúvida, sinta-se à vontade para deixar nos comentários!

Abs e até a próxima.
:wq!