Somos a equipe Catatau.
Nossa proposta envolve explorar as possibilidades da ferramenta. Em construção…
Nossa ideia inicial foi de desenvolver um sistema distribuído de inferência com o Llama3.2 7b, focando principalmente em uma ferramenta que pudesse auxiliar os usuários a desenvolverem e entenderem um pouco mais sobre as funcionalidades e opções da MagaluCloud, além disso ainda permitindo uma análise mais profunda sobre suas métricas como latência nas inferências. Porém, ao longo do caminho tivemos grandes problemas, como a integração do terraform com as funcionalidades do Magalu Cloud, abaixo levantei alguns pontos importantes compilados.
Interface de Linha de Comando (CLI): Alguns comandos do CLI, como listar diferentes tipos de modelos, resultam em tabelas vazias. Além disso, cada comando listado exibe todas as opções, mesmo sem a utilização do --help , o que pode comprometer a clareza e objetividade na utilização.
Funções de Armazenamento (Bucket Storage): (aparentemente) Não há atualmente uma funcionalidade de sincronização (upload) de arquivos locais para o storage. Isso impacta diretamente a agilidade no carregamento de dados e configurações necessárias para o trabalho no ambiente de desenvolvimento.
Timeouts nas VMs: Tentativas de baixar modelos e dependências diretamente do Terraform para a VM geraram problemas de timeout, o que atrasou o fluxo de desenvolvimento e implementação de novos módulos.
Conectividade com VMs: Ausência de detalhes no console sobre a forma de efetuar conexões diretas com as VMs, via SSH ou outros meios. Seria uma informação interessante e intuitiva para ajudar novos usuários a utilizarem da ferramenta.
Chaves de Acesso: Observamos que o processo de acesso e gerenciamento das chaves não é intuitivo, o que pode gerar frustrações para novos usuários ao configurar o ambiente.
main.tf utilizado:
# main.tf
terraform {
required_providers {
mgc = {
source = "magalucloud/mgc"
}
}
}
provider "mgc" {
alias = "sudeste"
region = "br-ne1"
}
# Instance
resource "mgc_virtual_machine_instances" "llama_instance" {
provider = mgc.sudeste
name = "llama-api-server-1"
machine_type = {
name = "BV4-8-100" # Increased to small for better performance
}
image = {
name = "cloud-ubuntu-22.04 LTS"
}
network = {
associate_public_ip = true
delete_public_ip = false
interface = {
security_groups = [{
id = "503cb0a3-3cfc-487f-9b96-70970694678c"
}]
}
}
ssh_key_name = "caio-test-ssh"
# Setup script
# provisioner "file" {
# source = "setup"
# destination = "/home/ubuntu/setup"
# }
# provisioner "remote-exec" {
# inline = [
# "chmod +x /home/ubuntu/setup/install.sh",
# "sudo /home/ubuntu/setup/install.sh"
# ]
# }
connection {
type = "ssh"
user = "root"
private_key = file("~/.ssh/id_ed25519")
host = self.network.public_address
}
}
# Output
output "instance_ip" {
value = mgc_virtual_machine_instances.llama_instance.network.public_address
}
output "ssh_command" {
value = "ssh -i ~/.ssh/id_ed25519 root@${mgc_virtual_machine_instances.llama_instance.network.public_address}"
}
Primeira tentativa de gerar uma API dentro de uma VM, instanciando também um modelo Llama
#!/bin/bash
# setup/install.sh
# Update system
sudo apt-get update
sudo apt-get upgrade -y
# Install dependencies
sudo apt-get install -y python3-pip python3-venv curl
# Install Ollama
curl https://ollama.ai/install.sh | sh
# Create Python virtual environment
python3 -m venv /home/ubuntu/venv
source /home/ubuntu/venv/bin/activate
# Install Python packages
pip install fastapi uvicorn redis ollama python-dotenv
# Pull LLaMA model
ollama pull llama3.2
# Create API service
cat > /home/ubuntu/api.py << 'EOL'
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import ollama
import asyncio
app = FastAPI()
class ChatRequest(BaseModel):
message: str
model: str = "llama3.2:1b"
system: str = None
class ChatResponse(BaseModel):
response: str
model: str
@app.post("/chat")
async def chat(request: ChatRequest):
try:
messages = []
if request.system:
messages.append({
"role": "system",
"content": request.system
})
messages.append({
"role": "user",
"content": request.message
})
response = await asyncio.to_thread(
ollama.chat,
model=request.model,
messages=messages
)
return ChatResponse(
response=response['message']['content'],
model=request.model
)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/models")
async def list_models():
try:
models = await asyncio.to_thread(ollama.list)
return {"models": models}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
EOL
# Create systemd service
sudo tee /etc/systemd/system/llama-api.service << EOL
[Unit]
Description=LLaMA API Service
After=network.target
[Service]
User=ubuntu
WorkingDirectory=/home/ubuntu
Environment="PATH=/home/ubuntu/venv/bin"
ExecStart=/home/ubuntu/venv/bin/python /home/ubuntu/api.py
Restart=always
[Install]
WantedBy=multi-user.target
EOL
# Start and enable service
sudo systemctl daemon-reload
sudo systemctl enable llama-api
sudo systemctl start llama-api
A segunda tentativa envolveu diversas iterações nos códigos a fim de tentar possibilitar uma abordagem utilizando Docker para a inicialização da API e dos modelos
# !/bin/bash
# setup/install.sh
# Update system
sudo apt-get update
sudo apt-get upgrade -y
# Install Docker
curl -fsSL <https://get.docker.com> -o get-docker.sh
sudo sh get-docker.sh
# Install Docker Compose
sudo apt-get install -y docker-compose-plugin
# Add ubuntu user to docker group
sudo usermod -aG docker ubuntu
# Start Docker service
sudo systemctl start docker
sudo systemctl enable docker
# Navigate to setup directory
cd /home/ubuntu/setup
# Pull LLaMA model
sudo docker compose up -d ollama
# sudo docker exec ollama ollama pull llama3.2:1b
# Start all services
sudo docker compose up -d
# Print status
sudo docker compose ps
Por fim, vou deixar uma imagem do front-end que desenvolvemos, disponível no repositório: GitHub - BrenoShini/Hackathon-Magalu-Cloud
Nele é possível ter uma melhor noção de como seria a plataforma para o usuário final.
Uma pena, por conta dos erros enfrentados, não termos conseguido fazer as integrações e nem finalizado o projeto como planejado.
1 curtida