Easyllmops
1.0.0
Easyllmops: Mlops sem esforço para modelos de linguagem poderosos.
O Easyllmops é um projeto construído com Webui aberto que pode ser implantado no Google Kubernetes Engine (GKE) para gerenciar e dimensionar modelos de linguagem. Oferece métodos de implantação de Terraform e Manual e incorpora práticas robustas do MLOPS. Isso inclui pipelines de CI/CD com Jenkins e Ansible para automação, monitoramento com Prometheus e Grafana para obter informações sobre desempenho e registro centralizado com a pilha de alces para solução de problemas e análise. Os desenvolvedores podem encontrar documentação e instruções detalhadas no site do projeto.
Desenvolvedores construindo e implantando aplicativos movidos a LLM. Cientistas de dados e engenheiros de aprendizado de máquina que trabalham com o LLMS. As equipes do DevOps responsáveis pelo gerenciamento da infraestrutura LLM. Organizações que desejam integrar o LLMS em suas operações.
Caso você não queira gastar muito tempo, execute este script e aproveite seu café:
chmod +x ./cluster.sh
./cluster.shLembre -se de autenticar com o GCP antes de usar o Terraform:
gcloud auth application-default loginEsta seção fornece um guia de partida 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 você estiver implantando o aplicativo para GKE, poderá usar o Terraform para automatizar a configuração do seu cluster Kubernetes. Navegue até o diretório iac/terraform e inicialize o Terraform:
cd iac/terraform
terraform initPlaneje e aplique a configuração:
Gere um plano de execução para verificar os recursos que a Terraform criará ou modificará e, em seguida, aplicará a configuração para configurar o cluster:
terraform plan
terraform apply2. Recupere as informações do cluster:
Para interagir com o seu cluster GKE, você precisará recuperar sua configuração. Você pode visualizar a configuração atual do cluster com o seguinte comando:
cat ~ /.kube/config Verifique se o seu contexto kubectl está definido corretamente para gerenciar o cluster.
Para um processo de implantação mais prático, siga estas etapas:
1. Implante o controlador de entrada nginx:
O controlador de entrada nginx gerencia o acesso externo aos serviços em seu cluster Kubernetes. Crie um espaço para nome e instale o controlador de entrada usando o Helm:
kubectl create ns nginx-system
kubens nginx-system
helm upgrade --install nginx-ingress ./deployments/nginx-ingressPor favor, historasse o endereço IP do controlador de entrada nginx, como você precisará mais tarde.
2. Configure o segredo da chave da API:
Armazene suas variáveis de ambiente, como as chaves da API, com segurança nos segredos Kubernetes. Crie um espaço para nome para o modelo que serve 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. Permissões de concessão:
Os recursos da Kubernetes geralmente exigem permissões específicas. Aplique as funções e ligações necessárias:
cd deployments/infrastructure
kubectl apply -f role.yaml
kubectl apply -f rolebinding.yaml4. Implante 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 Litellm:
Implante o serviço Litellm:
kubens model-serving
helm upgrade --install litellm ./deployments/litellm6. Implante o webui aberto:
Em seguida, implante a interface do usuário da web no seu cluster GKE:
cd open-webui
kubectl apply -f ./kubernetes/manifest/base -n model-serving7. Brinque com o aplicativo:
Abra o navegador e navegue até o URL do seu cluster da 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ê deve ver o webui aberto:
Para pipelines de IC/CD automatados, use Jenkins e Ansible da seguinte forma:
1. Configure o servidor Jenkins:
Primeiro, crie uma conta de serviço e atribua -a a função Compute Admin . Em seguida, crie um arquivo de chave JSON para a conta de serviço e guarde -o no diretório iac/ansible/secrets .
Em seguida, crie uma instância do mecanismo do Google Compute chamada "Jenkins-Server", executando o Ubuntu 22.04 com uma regra de firewall, permitindo o tráfego nas portas 8081 e 50000.
ansible-playbook iac/ansible/deploy_jenkins/create_compute_instance.yamlImplante Jenkins em um servidor instalando pré -requisitos, puxando uma imagem do Docker e criando um contêiner privilegiado com acesso ao soquete do docker e portas expostas 8081 e 50000.
ansible-playbook -i iac/ansible/inventory iac/ansible/deploy_jenkins/deploy_jenkins.yaml2. Acesso Jenkins:
Para acessar o servidor Jenkins através do SSH, precisamos criar um par público/privado. 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/initialAdminPasswordQuando Jenkins for implantado, acesse -o através do seu navegador:
http://:8081
3. Instale os plugins Jenkins:
Instale os seguintes plugins para integrar Jenkins com Docker, Kubernetes e GKE:
Depois de instalar os plugins, reinicie Jenkins.
sudo docker restart jenkins-server4. Configure Jenkins:
4.1. Adicione webhooks ao seu repositório do GitHub para acionar as compilações Jenkins.
Vá para o repositório do GitHub e clique nas Settings . Clique em Webhooks e clique em Add Webhook . Digite o URL do seu servidor Jenkins (por exemplo http:// ). Em seguida, clique em Let me select individual events e selecionar Let me select individual events . Selecione Push e Pull Request e clique em Add Webhook .
4.2. Adicione o repositório do GitHub como um repositório de código -fonte Jenkins.
Vá para o painel Jenkins e clique no New Item . Digite um nome para o seu projeto (por exemplo, easy-llmops ) e selecione Multibranch Pipeline . Clique em OK . Clique em Configure e clique em Add Source . Selecione GitHub e clique em Add . Digite o URL do seu repositório do 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 na Test Connection e clique em Save .
4.3. Credenciais de configuração do Docker Hub.
Primeiro, crie uma conta do Docker Hub. Vá para 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 .
Do painel Jenkins, vá para Manage Jenkins > Credentials . Clique em Add Credentials . Selecione Username with password e clique em Add . Digite o nome de usuário do Docker Hub, acesse token e defina ID como dockerhub .
4.4. Configure credenciais Kubernetes.
Primeiro, crie uma conta de serviço para o servidor Jenkins para acessar o cluster GKE. Vá para o console do GCP e navegue até as contas de serviço iam & admin>. Crie uma nova conta de serviço com a função Kubernetes Engine Admin . Dê um nome e descrição à conta de serviço. Clique na conta de serviço e clique na guia Keys . Clique em Add Key e selecione JSON como o tipo de chave. Clique em Create e baixar o arquivo JSON.
Então, no painel Jenkins, vá para Manage Jenkins > Cloud . Clique na New cloud . Selecione Kubernetes . Digite o nome do seu cluster (por exemplo, gke-easy-llmops-cluster-1), enter the URL and Certificate from your GKE cluster. In the espaço para nome de Kubernetes , enter the namespace of your cluster (eg serve o modelo ). In the field, select Adicionar and select a conta do Google Service em private`. Digite seu ID do projeto e o caminho para o arquivo JSON.
5. Teste a configuração:
Empurre um novo compromisso com o seu repositório do GitHub. Você deve ver uma nova construção em Jenkins.
1. Crie discord webhook:
Primeiro, crie um Webhook Discord. Vá para o site da Discord e clique nas 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 da webhook.
2. Configure repositórios de leme
Primeiro, precisamos adicionar os repositórios de comando 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 de Prometheus e Grafana Helm e atualizam as informações locais do gráfico de comando.
3. Instale dependências
Prometeu requer certas dependências que podem ser gerenciadas com o comando. Navegue até o diretório de monitoramento e construa estas dependências:
helm dependency build ./deployments/monitoring/kube-prometheus-stack4. Implante Prometheus
Agora, nós implantaremos a Prometheus e seus serviços associados usando o comando:
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 não existir ou atualizá -lo se o fizer.-f deployments/monitoring/kube-prometheus-stack.expanded.yaml : Isso especifica um arquivo de valores personalizado para a configuração.kube-prometheus-stack : Este é o nome da versão para a instalação do comando.deployments/monitoring/kube-prometheus-stack : Este é o gráfico a ser usado para instalação.-n monitoring : Isso especifica o espaço para o nome para instalar.Por padrão, os serviços não são expostos externamente. Para acessá-los, você pode usar a porta de antecedência:
Para Prometheus:
kubectl port-forward -n monitoring svc/kube-prometheus-stack-prometheus 9090:9090 Em seguida, acesse Prometheus em http://localhost:9090
Para Grafana:
kubectl port-forward -n monitoring svc/kube-prometheus-stack-grafana 3000:80 Em seguida, acesse Grafana em http://localhost:3000
As credenciais padrão para 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.
Essa configuração fornece recursos de monitoramento abrangentes para o seu cluster Kubernetes. Com a Prometheus coletando métricas e o Grafana visualizando -as, você pode rastrear efetivamente o desempenho, configurar alertas para possíveis problemas e obter informações valiosas sobre sua infraestrutura e aplicativos.
O registro centralizado é essencial para o monitoramento e a solução de problemas de aplicativos implantados em Kubernetes. Esta seção o guia até a configuração de uma pilha de alces (Elasticsearch, Logstash, Kibana) com o Filebeat para registrar seu cluster GKE.
0. Execução rápida
Você pode usar este script de helmfile único para iniciar a pilha de alces:
cd deployments/ELK
helmfile sync1. Instale a pilha de alces com leme
Usaremos o leme para implantar os componentes da pilha de alces:
Primeiro, crie um espaço para nome 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 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. Acesso Kibana:
Exponha Kibana usando um serviço e acesse -o através do seu navegador:
kubectl port-forward -n logging svc/elk-kibana-kibana 5601:5601Por favor, use este script para obter a senha de Kibana:
kubectl get secrets --namespace=logging elasticsearch-master-credentials -ojsonpath= ' {.data.password} ' | base64 -d Abra o navegador e navegue para http://localhost:5601 .
3. Verifique a coleção de logs
Agora você deve poder ver logs de suas vagens Kubernetes em Kibana. Você pode criar painéis e visualizações para analisar seus logs e obter informações sobre o comportamento do seu aplicativo.
Por favor, vá para lançar a IA 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 " " https://api.cast.ai/v1/agent.yaml?provider=gke " | kubectl apply -f - Bata I ran this script na interface do usuário do elenco, depois copie o código de configuração e colo -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 ' ) " Bata, I ran this script novamente e waite para a instalação ser concluída.
Então você pode ver seus painéis na interface do usuário do elenco da AI:
É hora de otimizar seu cluster com o elenco AI! Vá para a Available savings e clique no botão Rebalance .
Vá para Langfuse e Supabase para se inscrever em uma conta gratuita e obter teclas de API e substitua os placehoders no arquivo .env.example pelas suas teclas API.
Congratulamo -nos com contribuições para a easyllmops! Consulte o nosso contribuindo.md para obter mais informações sobre como começar.
O Easyllmops é liberado sob a licença do MIT. Consulte o arquivo de licença para obter mais detalhes.
Se você usar o Easyllmops em sua pesquisa, cite -a 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 perguntas, questões ou colaborações, abra um problema em nosso repositório do GitHub ou entre em contato diretamente com os mantenedores.
