{"id":63719,"date":"2021-10-25T17:00:23","date_gmt":"2021-10-25T16:00:23","guid":{"rendered":"https:\/\/www.artefact.com\/?post_type=news&p=63719"},"modified":"2024-09-20T17:45:46","modified_gmt":"2024-09-20T16:45:46","slug":"serving-ml-models-at-scale-using-mlflow-on-kubernetes-part-2","status":"publish","type":"blog","link":"https:\/\/www.artefact.com\/nl\/blog\/serving-ml-models-at-scale-using-mlflow-on-kubernetes-part-2\/","title":{"rendered":"ML-modellen op schaal serveren met Mlflow op Kubernetes - Deel 2"},"content":{"rendered":"

Auteur<\/h2><\/div>\"Image\"

Kais Laribi<\/h3><\/div>

Senior Data Wetenschapper bij Artefact<\/p>\n<\/div><\/div><\/div><\/div><\/div>

<\/span><\/a><\/span>

Lees ons artikel over<\/u><\/p>\n<\/div>

<\/span><\/div>

.<\/p>\n<\/div><\/div><\/div><\/div><\/div>

Dit artikel is het tweede deel van een serie waarin we het proces doorlopen van het loggen van modellen met behulp van Mlflow, ze serveren als API endpoint en ze uiteindelijk opschalen naargelang de behoeften van onze applicatie. We raden u aan om ons vorige artikel te lezen, waarin we laten zien hoe u een volginstantie op k8s kunt implementeren en de praktische vereisten (geheimen, omgevingsvariabelen...) kunt controleren, omdat we daar hier verder op zullen bouwen.
\nIn het volgende laten we zien hoe u een machine-learningmodel dat al geregistreerd is in Mlflow kunt serveren en als API-eindpunt op k8s kunt blootstellen.<\/p>\n<\/div><\/div><\/div><\/div><\/div>

Deel 2- Hoe een model als API op Kubernetes serveren?<\/h1><\/div>

Inleiding<\/h2><\/div>

Het is duidelijk dat het bijhouden en optimaliseren van de prestaties van modellen een belangrijk onderdeel is van het maken van ML-modellen. De volgende uitdaging is om ze te integreren in een toepassing of product om hun voorspellingen te gebruiken. Dit noemen we modellen serveren of inferentie. Er zijn verschillende raamwerken en technieken waarmee we dit kunnen doen. Toch zullen we ons hier richten op Mlflow en laten zien hoe effici\u00ebnt en eenvoudig het kan zijn.<\/p>\n<\/div>

De serverafbeelding bouwen en implementeren<\/h2><\/div>

De verschillende configuratiebestanden die hier gebruikt worden, maken deel uit van de\u00a0praktijkgerichte opslagplaats<\/a>\u00a0In principe moeten we:<\/p>\n<\/div>

1. Bereid het Mlflow serving docker image voor en push het naar de containerregistry op GCP.<\/h3><\/div>
cd mlflow-serving-voorbeeld<\/span>docker build --tag $\/mlflow_serving:v1 
--bestand docker_mlflow_serving .<\/span>docker push $\/mlflow_serving:v1<\/span><\/pre>\n<\/div>
2. Het Kubernetes implementatiebestand voorbereiden<\/h3><\/div>
door de containersectie te wijzigen en deze toe te wijzen aan de\u00a0docker-afbeelding<\/strong>\u00a0eerder naar GCR geduwd,\u00a0het modelpad<\/strong>\u00a0en\u00a0de serverende poort.<\/strong><\/p>\n<\/div>
\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
apiVersion<\/span>: apps\/v1<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nvriendelijk<\/span>: Inzet<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nmetadata<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\nnaam<\/span>: mlflow-serving<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\netiketten<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\napp<\/span>: dien-ML-model-mlflow<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
\u00a0<\/td>\nspec<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\nreplica's<\/span>: 1<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nselector<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\nmatchLabels<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\napp<\/span>: mlflow-serving<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nsjabloon<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\nmetadata<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\netiketten<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\napp<\/span>: mlflow-serving<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
\u00a0<\/td>\nspec<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\ncontainers<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\n- naam<\/span>: mlflow-serving<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nAfbeelding<\/span>: GCR_REPO\/mlflow_serving:v1 <\/span>1TP45Wissel hier<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nomgeving<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\n- naam<\/span>: MODEL_URI<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nwaarde<\/span>: \u201c<\/span>gs:\/\/..\/artifacts\/..\/..\/artifacts\/..\u201c<\/span><\/span> 1TP45Wissel hier<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\n- naam<\/span>: DIENSTPOORT<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nwaarde<\/span>: \u201c<\/span>8082\u201c<\/span><\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\n- naam<\/span>: GOOGLE_TOEPASSING_GEGEVENS<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nwaarde<\/span>: \u201c<\/span>\/etc\/secrets\/sleutelbestand.json\u201c<\/span><\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nvolumeMounts<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\n- naam<\/span>: gcsfs-creds<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nmountPath<\/span>: \u201c<\/span>\/etc\/secrets\u201c<\/span><\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nalleen-lezen<\/span>: Echt<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nmiddelen<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\nverzoekt<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\ncpu<\/span>: \u201c<\/span>1000m\u201c<\/span><\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
\u00a0<\/td>\n\u00a0<\/td>\n<\/tr>\n
\u00a0<\/td>\nvolumes<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\n- naam<\/span>: gcsfs-creds<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\ngeheim<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\nsecretName<\/span>: gcsfs-creds<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\nitems<\/span>:<\/td>\n<\/tr>\n
\u00a0<\/td>\n- toets<\/span>: sleutelbestand.json<\/span><\/td>\n<\/tr>\n
\u00a0<\/td>\npad<\/span>: sleutelbestand.json<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>
3. Implementatieopdrachten uitvoeren<\/h3><\/div>
kubectl create -f deployments\/mlflow-serving\/mlflow_serving.yaml<\/p>\n<\/div>
4. Stel de implementatie open voor externe toegang<\/h3><\/div>
Met de volgende opdracht wordt een nieuwe resource aangemaakt om extern verkeer om te leiden naar onze API.<\/p>\n
kubectl expose deployment mlflow-serving --port 8082 --type=\"LoadBalancer\"<\/span><\/pre>\n<\/div>
5. Controleer de implementatie en vraag het eindpunt op<\/h3><\/div>
Als de implementatie succesvol is, zou mlflow-serving UP moeten zijn en zou er \u00e9\u00e9n pod beschikbaar moeten zijn. U kunt dat controleren door te typen\u00a0kubectl get pods<\/strong><\/em><\/p>\n<\/div>
<\/span><\/div>
De laatste stap is het controleren van het externe IP-adres dat werd toegewezen aan de loadbalancer die het verkeer omleidt naar onze API-container met behulp van\u00a0kubectl get diensten<\/em><\/strong>\u00a0en test de respons op een paar query's.<\/p>\n<\/div>
<\/span><\/div>
Een voorbeeldcode om deze query's uit te voeren vindt u in het volgende\u00a0notebook<\/a>\u00a0waarin we enkele rijen van data laden, kenmerken selecteren, converteren naar JSON-formaat en in een postverzoek naar de API sturen.
\nAls we nu de stappen uit ons vorige en huidige artikel combineren, ziet onze uiteindelijke architectuur er als volgt uit:<\/p>\n<\/div>
<\/span><\/div>
Conclusie<\/h2><\/div>
In dit artikel hebben we laten zien dat we eenvoudig machine learning-modellen kunnen implementeren als een API eindpunt met behulp van de Mlflow serving module.<\/p>\n
Zoals u misschien ziet, is er in onze huidige implementatie slechts \u00e9\u00e9n pod aangemaakt om het model te bedienen. Hoewel dit goed werkt voor kleine toepassingen waar we niet meerdere parallelle queries verwachten, zou het snel zijn grenzen kunnen laten zien op andere toepassingen, aangezien een enkele pod beperkte bronnen heeft. Bovendien kan de applicatie op deze manier niet meer dan \u00e9\u00e9n node aan rekenkracht gebruiken. In het volgende en laatste artikel van deze serie zullen we het schaalbaarheidsprobleem aanpakken. We zullen eerst de knelpunten belichten en proberen deze op te lossen om een schaalbare applicatie te krijgen die gebruik maakt van de kracht van ons Kubernetes-cluster.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
<\/span><\/div>
Medium Blog bij Artefact.<\/h3><\/div>
Dit artikel werd oorspronkelijk gepubliceerd op Medium.com<\/strong>.
\nVolg ons op ons medium Blog !<\/p>\n<\/div>
Lees ons artikel<\/span><\/a><\/div><\/div><\/div><\/div><\/div><\/p>","protected":false},"excerpt":{"rendered":"
25 oktober 2021
\nDit artikel is het tweede deel van een serie waarin we het proces doorlopen van het loggen van modellen met behulp van Mlflow, ze serveren als API endpoint en ze uiteindelijk opschalen naargelang de behoeften van onze applicatie. We raden u aan om ons vorige artikel te lezen, waarin we laten zien hoe u een volginstantie op k8s kunt implementeren en de praktische vereisten (geheimen, omgevingsvariabelen...) kunt controleren, omdat we daar hier verder op zullen bouwen.
\nIn het volgende laten we zien hoe u een machine-learningmodel dat al geregistreerd is in Mlflow kunt serveren en als API-eindpunt op k8s kunt blootstellen.<\/p>","protected":false},"featured_media":65014,"parent":0,"template":"","meta":{"_acf_changed":false,"ep_exclude_from_search":false},"blog-category":[21939],"blog-language":[2991],"class_list":["post-63719","blog","type-blog","status-publish","has-post-thumbnail","hentry","blog-category-medium","blog-language-en"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog\/63719","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog"}],"about":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/types\/blog"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/media\/65014"}],"wp:attachment":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/media?parent=63719"}],"wp:term":[{"taxonomy":"blog-category","embeddable":true,"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog-category?post=63719"},{"taxonomy":"blog-language","embeddable":true,"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog-language?post=63719"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}