EasyLLMOps
1.0.0
EasyLLMOps: MLOps sem esforço para modelos de linguagem poderosos.
EasyLLMOps é um projeto construído com Open WebUI que pode ser implantado no Google Kubernetes Engine (GKE) para gerenciar e dimensionar modelos de linguagem. Ele oferece métodos de implantação manual e Terraform e incorpora práticas robustas de MLOps. Isso inclui pipelines de CI/CD com Jenkins e Ansible para automação, monitoramento com Prometheus e Grafana para insights de desempenho e registro centralizado com a pilha ELK para solução de problemas e análise. Os desenvolvedores podem encontrar documentação e instruções detalhadas no site do projeto.
Desenvolvedores que criam e implantam aplicativos com tecnologia LLM. Cientistas de dados e engenheiros de aprendizado de máquina trabalhando com LLMs. Equipes DevOps responsáveis pelo gerenciamento da infraestrutura LLM. Organizações que buscam integrar LLMs em suas operações.
Caso você não queira perder muito tempo, execute este script e aproveite seu café:
chmod +x ./cluster.sh
./cluster.shLembre-se de autenticar no GCP antes de usar o Terraform:
gcloud auth application-default loginEsta seção fornece um guia de início muito rápido para colocar o aplicativo em funcionamento o mais rápido possível. Consulte as seções a seguir para obter instruções mais detalhadas.
1. Configure o cluster:
Se estiver implantando o aplicativo no GKE, você poderá usar o Terraform para automatizar a configuração do cluster Kubernetes. Navegue até o diretório iac/terraform e inicialize o Terraform:
cd iac/terraform
terraform initPlanejar e aplicar configuração:
Gere um plano de execução para verificar os recursos que o Terraform criará ou modificará e, em seguida, aplique a configuração para configurar o cluster:
terraform plan
terraform apply2. Recuperar informações do cluster:
Para interagir com seu cluster do GKE, você precisará recuperar a configuração dele. Você pode visualizar a configuração atual do cluster com o seguinte comando:
cat ~ /.kube/config Certifique-se de que seu contexto kubectl esteja configurado corretamente para gerenciar o cluster.
Para um processo de implantação mais prático, siga estas etapas:
1. Implante o controlador de ingresso Nginx:
O Nginx Ingress Controller gerencia o acesso externo aos serviços em seu cluster Kubernetes. Crie um namespace e instale o Ingress Controller usando Helm:
kubectl create ns nginx-system
kubens nginx-system
helm upgrade --install nginx-ingress ./deployments/nginx-ingressInforme o endereço IP do controlador Nginx Ingress, pois você precisará dele mais tarde.
2. Configure o segredo da chave de API:
Armazene suas variáveis de ambiente, como chaves de API, com segurança em segredos do Kubernetes. Crie um namespace para serviço de modelo e crie um segredo do seu arquivo .env :
kubectl create ns model-serving
kubens model-serving
kubectl delete secret easyllmops-env
kubectl create secret generic easyllmops-env --from-env-file=.env -n model-serving
kubectl describe secret easyllmops-env -n model-serving3. Conceder permissões:
Os recursos do Kubernetes geralmente exigem permissões específicas. Aplique as funções e vinculações necessárias:
cd deployments/infrastructure
kubectl apply -f role.yaml
kubectl apply -f rolebinding.yaml4. Implante o serviço de cache usando Redis:
Agora, implante o serviço de cache semântico usando Redis:
cd ./deployments/redis
helm dependency build
helm upgrade --install redis .5. Implante o LiteLLM:
Implante o serviço LiteLLM:
kubens model-serving
helm upgrade --install litellm ./deployments/litellm6. Implante o WebUI aberto:
Em seguida, implante a IU da Web no cluster do GKE:
cd open-webui
kubectl apply -f ./kubernetes/manifest/base -n model-serving7. Experimente o aplicativo:
Abra o navegador e navegue até o URL do seu cluster do GKE (por exemplo, http://172.0.0.0 na etapa 1) e adicione .nip.io ao final do URL (por exemplo, http://172.0.0.0.nip.io ) . Você deverá ver o Open WebUI:
Para pipelines automatizados de CI/CD, use Jenkins e Ansible da seguinte maneira:
1. Configure o servidor Jenkins:
Primeiro, crie uma conta de serviço e atribua a ela a função Compute Admin . Em seguida, crie um arquivo de chave Json para a conta de serviço e armazene-o no diretório iac/ansible/secrets .
Em seguida, crie uma instância do Google Compute Engine chamada "jenkins-server" executando Ubuntu 22.04 com uma regra de firewall permitindo tráfego nas portas 8081 e 50000.
ansible-playbook iac/ansible/deploy_jenkins/create_compute_instance.yamlImplante o Jenkins em um servidor instalando pré-requisitos, extraindo uma imagem do Docker e criando um contêiner privilegiado com acesso ao soquete do Docker e às portas expostas 8081 e 50000.
ansible-playbook -i iac/ansible/inventory iac/ansible/deploy_jenkins/deploy_jenkins.yaml2. Acesse Jenkins:
Para acessar o servidor Jenkins através de SSH, precisamos criar um par de chaves pública/privada. Execute o seguinte comando para criar um par de chaves:
ssh-keygen Abra Metadata e copie o valor ssh-keys .
Precisamos encontrar a senha do servidor Jenkins para poder acessar o servidor. Primeiro, acesse o servidor Jenkins:
ssh < USERNAME > : < EXTERNAL_IP >Em seguida, execute o seguinte comando para obter a senha:
sudo docker exec -it jenkins-server bash
cat /var/jenkins_home/secrets/initialAdminPasswordDepois que o Jenkins estiver implantado, acesse-o através do seu navegador:
http://<EXTERNAL_IP>:8081
3. Instale os plug-ins Jenkins:
Instale os seguintes plug-ins para integrar Jenkins com Docker, Kubernetes e GKE:
Após instalar os plugins, reinicie o Jenkins.
sudo docker restart jenkins-server4. Configure o Jenkins:
4.1. Adicione webhooks ao seu repositório GitHub para acionar compilações do Jenkins.
Vá para o repositório GitHub e clique em Settings . Clique em Webhooks e depois clique em Add Webhook . Insira a URL do seu servidor Jenkins (por exemplo http://<EXTERNAL_IP>:8081/github-webhook/ ). Em seguida, clique em Let me select individual events e selecione Let me select individual events . Selecione Pull Request Push e Pull e clique em Add Webhook .
4.2. Adicione o repositório Github como um repositório de código-fonte Jenkins.
Vá para o painel do Jenkins e clique em New Item . Insira um nome para o seu projeto (por exemplo, easy-llmops ) e selecione Multibranch Pipeline . Clique em OK . Clique em Configure e depois clique em Add Source . Selecione GitHub e clique em Add . Insira a URL do seu repositório GitHub (por exemplo, https://github.com/bmd1905/EasyLLMOps ). No campo Credentials , selecione Add e selecione Username with password . Digite seu nome de usuário e senha do GitHub (ou use um token de acesso pessoal). Clique em Test Connection e depois clique em Save .
4.3. Configure as credenciais do docker hub.
Primeiro, crie uma conta Docker Hub. Acesse o site do Docker Hub e clique em Sign Up . Digite seu nome de usuário e senha. Clique em Sign Up . Clique em Create Repository . Digite um nome para o seu repositório (por exemplo, easy-llmops ) e clique em Create .
No painel do Jenkins, vá para Manage Jenkins > Credentials . Clique em Add Credentials . Selecione Username with password e clique em Add . Insira seu nome de usuário do Docker Hub, token de acesso e defina ID como dockerhub .
4.4. Configure as credenciais do Kubernetes.
Primeiro, crie uma conta de serviço para o servidor Jenkins acessar o cluster do GKE. Acesse o console do GCP e navegue até IAM e administrador > Contas de serviço. Crie uma nova conta de serviço com o papel Kubernetes Engine Admin . Dê um nome e uma descrição à conta de serviço. Clique na conta de serviço e, em seguida, clique na guia Keys . Clique em Add Key e selecione JSON como o tipo de chave. Clique em Create e baixe o arquivo JSON.
Em seguida, no painel do Jenkins, vá para Manage Jenkins > Cloud . Clique em New cloud . Selecione Kubernetes . Insira o nome do seu cluster (por exemplo, gke-easy-llmops-cluster-1), enter the URL and Certificate from your GKE cluster. In the Namespace Kubernetes , enter the namespace of your cluster (eg model-serving ). In the field, select Adicionar and select Conta de serviço do Google em particular`. Insira o ID do seu projeto e o caminho para o arquivo JSON.
5. Teste a configuração:
Envie um novo commit para seu repositório GitHub. Você deverá ver uma nova compilação no Jenkins.
1. Crie o webhook do Discord:
Primeiro, crie um webhook do Discord. Acesse o site do Discord e clique em Server Settings . Clique em Integrations . Clique em Create Webhook . Digite um nome para o seu webhook (por exemplo, easy-llmops-discord-webhook ) e clique em Create . Copie o URL do webhook.
2. Configurar repositórios Helm
Primeiro, precisamos adicionar os repositórios Helm necessários para Prometheus e Grafana:
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo add grafana https://grafana.github.io/helm-charts
helm repo updateEsses comandos adicionam os repositórios oficiais do Prometheus e Grafana Helm e atualizam as informações do gráfico local do Helm.
3. Instale dependências
O Prometheus requer certas dependências que podem ser gerenciadas com Helm. Navegue até o diretório de monitoramento e crie estas dependências:
helm dependency build ./deployments/monitoring/kube-prometheus-stack4. Implante o Prometheus
Agora, implantaremos o Prometheus e seus serviços associados usando Helm:
kubectl create namespace monitoring
helm upgrade --install -f deployments/monitoring/kube-prometheus-stack.expanded.yaml kube-prometheus-stack deployments/monitoring/kube-prometheus-stack -n monitoringEste comando faz o seguinte:
helm upgrade --install : Isso instalará o Prometheus se ele não existir ou o atualizará se existir.-f deployments/monitoring/kube-prometheus-stack.expanded.yaml : especifica um arquivo de valores personalizados para configuração.kube-prometheus-stack : este é o nome da versão da instalação do Helm.deployments/monitoring/kube-prometheus-stack : este é o gráfico a ser usado para instalação.-n monitoring : especifica o namespace no qual instalar.Por padrão, os serviços não são expostos externamente. Para acessá-los, você pode usar o encaminhamento de porta:
Para Prometeu:
kubectl port-forward -n monitoring svc/kube-prometheus-stack-prometheus 9090:9090 Em seguida, acesse o Prometheus em http://localhost:9090
Para Grafana:
kubectl port-forward -n monitoring svc/kube-prometheus-stack-grafana 3000:80 Então acesse o Grafana em http://localhost:3000
As credenciais padrão do Grafana são geralmente:
5. Alerta de teste
Primeiro precisamos criar um alerta de amostra. Navegue até o diretório monitoring e execute o seguinte comando:
kubectl port-forward -n monitoring svc/alertmanager-operated 9093:9093Então, em um novo terminal, execute o seguinte comando:
curl -XPOST -H " Content-Type: application/json " -d ' [
{
"labels": {
"alertname": "DiskSpaceLow",
"severity": "critical",
"instance": "server02",
"job": "node_exporter",
"mountpoint": "/data"
},
"annotations": {
"summary": "Disk space critically low",
"description": "Server02 has only 5% free disk space on /data volume"
},
"startsAt": "2023-09-01T12:00:00Z",
"generatorURL": "http://prometheus.example.com/graph?g0.expr=node_filesystem_free_bytes+%2F+node_filesystem_size_bytes+%2A+100+%3C+5"
},
{
"labels": {
"alertname": "HighMemoryUsage",
"severity": "warning",
"instance": "server03",
"job": "node_exporter"
},
"annotations": {
"summary": "High memory usage detected",
"description": "Server03 is using over 90% of its available memory"
},
"startsAt": "2023-09-01T12:05:00Z",
"generatorURL": "http://prometheus.example.com/graph?g0.expr=node_memory_MemAvailable_bytes+%2F+node_memory_MemTotal_bytes+%2A+100+%3C+10"
}
] ' http://localhost:9093/api/v2/alertsEste comando cria um alerta de amostra. Você pode verificar se o alerta foi criado executando o seguinte comando:
curl http://localhost:9093/api/v2/statusOu você pode verificar manualmente o canal Discord.
Esta configuração fornece recursos de monitoramento abrangentes para seu cluster Kubernetes. Com o Prometheus coletando métricas e o Grafana visualizando-as, você pode monitorar o desempenho com eficácia, configurar alertas para possíveis problemas e obter insights valiosos sobre sua infraestrutura e aplicativos.
O registro centralizado é essencial para monitorar e solucionar problemas de aplicativos implantados no Kubernetes. Esta seção orienta você na configuração de uma pilha ELK (Elasticsearch, Logstash, Kibana) com Filebeat para registrar seu cluster do GKE.
0. Corrida rápida
Você pode usar este script helmfile único para iniciar a pilha ELK:
cd deployments/ELK
helmfile sync1. Instale ELK Stack com Helm
Usaremos o Helm para implantar os componentes da pilha ELK:
Primeiro, crie um namespace para os componentes de registro:
kubectl create ns logging
kubens loggingEm seguida, instale o Elasticsearch:
helm install elk-elasticsearch elastic/elasticsearch -f deployments/ELK/elastic.expanded.yaml --namespace logging --create-namespaceAguarde o Elasticsearch estar pronto:
echo " Waiting for Elasticsearch to be ready... "
kubectl wait --for=condition=ready pod -l app=elasticsearch-master --timeout=300sCrie um segredo para o Logstash acessar o Elasticsearch:
kubectl create secret generic logstash-elasticsearch-credentials
--from-literal=username=elastic
--from-literal=password= $( kubectl get secrets --namespace=logging elasticsearch-master-credentials -ojsonpath= ' {.data.password} ' | base64 -d )Instale o Kibana:
helm install elk-kibana elastic/kibana -f deployments/ELK/kibana.expanded.yamlInstale o Logstash:
helm install elk-logstash elastic/logstash -f deployments/ELK/logstash.expanded.yamlInstale o Filebeat:
helm install elk-filebeat elastic/filebeat -f deployments/ELK/filebeat.expanded.yaml2. Acesse o Kibana:
Exponha o Kibana usando um serviço e acesse-o através do seu navegador:
kubectl port-forward -n logging svc/elk-kibana-kibana 5601:5601Use este script para obter a senha do Kibana:
kubectl get secrets --namespace=logging elasticsearch-master-credentials -ojsonpath= ' {.data.password} ' | base64 -d Abra seu navegador e navegue até http://localhost:5601 .
3. Verifique a coleta de logs
Agora você deve conseguir ver os logs dos seus pods do Kubernetes no Kibana. Você pode criar painéis e visualizações para analisar seus logs e obter insights sobre o comportamento do seu aplicativo.
Acesse Cast AI para se inscrever em uma conta gratuita e obter o TOKEN.
Em seguida, execute esta linha para se conectar ao GKE:
curl -H " Authorization: Token <TOKEN> " " https://api.cast.ai/v1/agent.yaml?provider=gke " | kubectl apply -f - Hit, I ran this script na IU do Cast AI, copiei o código de configuração e colei-o no terminal:
CASTAI_API_TOKEN= < API_TOKEN > CASTAI_CLUSTER_ID= < CASTAI_CLUSTER_ID > CLUSTER_NAME=easy-llmops-gke INSTALL_AUTOSCALER=true INSTALL_POD_PINNER=true INSTALL_SECURITY_AGENT=true LOCATION=asia-southeast1-b PROJECT_ID=easy-llmops /bin/bash -c " $( curl -fsSL ' https://api.cast.ai/v1/scripts/gke/onboarding.sh ' ) " Clique em I ran this script novamente e esperei que a instalação fosse concluída.
Então você pode ver seus painéis na IU do Cast AI:
Chegou a hora de otimizar seu cluster com Cast AI! Vá para a seção Available savings e clique no botão Rebalance .
Vá para Langfuse e Supabase para se inscrever para uma conta gratuita e obter chaves de API e, em seguida, substitua os placehoders no arquivo .env.example por suas chaves de API.
Aceitamos contribuições para EasyLLMOps! Consulte nosso CONTRIBUTING.md para obter mais informações sobre como começar.
EasyLLMOps é lançado sob a licença MIT. Consulte o arquivo LICENSE para obter mais detalhes.
Se você usa EasyLLMOps em sua pesquisa, cite-o da seguinte forma:
@software{EasyLLMOps2024,
author = {Minh-Duc Bui},
title = {EasyLLMOps: Effortless MLOps for Powerful Language Models.},
year = {2024},
url = {https://github.com/bmd1905/EasyLLMOps}
}
Para dúvidas, problemas ou colaborações, abra um problema em nosso repositório GitHub ou entre em contato diretamente com os mantenedores.
