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 .

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

O -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!

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!