---
# System prepended metadata

title: Quickstart Aquiles + Seldon Core (Cluster Local)

---

# Quickstart Aquiles + Seldon Core (Cluster Local)

Quickstart do Seldon Core utilizando o Aquiles em um kubernetes cluster local (Minikube ou Kind).

## Requisitos

* [Docker](https://docs.docker.com/engine/install/)
* [kubectl](https://kubernetes.io/docs/tasks/tools/)
* [kind ou minikube](https://kubernetes.io/docs/tasks/tools/)
* [Istio](https://istio.io/latest/docs/setup/getting-started/)
* [Helm](https://helm.sh/docs/intro/install/)

## Criar uma docker image encapsulando o modelo.

Essa etapa é necessária caso não exista alguma imagem docker do modelo em repositório, ou caso esteja sendo testado alguma nova versão da imagem com mudanças significativas na inferência.

Para utilizar um modelo próprio no Seldon Core é necessário definir uma classe de modelo que contenha uma função de predição adaptada para o Seldon Core API. Construir uma docker image que contenha o seldon core microservice e encapsular o modelo. Segue um passo a passo de como fazer isso:

No diretório deploy temos os arquivos necessários para construção da imagem do docker.
1. O arquivo "requirements.txt" contém as bibliotecas requiridas para a construção da imagem.
2. A pasta "models" contém todos o modelos necessários para realizar inferência.
3. O arquivo "seldon_inference.py" detém a definição da classe de predição treinado e a classe com a função de predição adaptada para o formato JSON.
4. Por fim, o arquivo "Dockerfile" é utilizado para construir a imagem e instalar requisitos.

Dentro da pasta dockerfiles, basta rodar o comando:

````
docker build . -t <my-model-image>
````
Substituindo "my-model-image" pelo nome desejado.

Com a imagem pronta, podemos testar se ela é capaz de retornar predições. 

````
docker run -p 9000:9000 --rm <my-model-image>
````
Com o curl mandamos uma request, o arquivo "infer.json" contém um exemplo de inferência para o aquiles. 
````
curl -X POST localhost:9000/api/v1.0/predictions -H 'Content-Type: application/json' -d @infer.json
````
O retorno deve conter a previsão do modelo.

Com o a imagem funcionando corretamente, basta subir ela para um repositório docker.

````
docker tag my-model-image test-repo/my-model-image

docker push test-repo/my-model-image
````

## Como rodar a inferência localmente

### Criar um Kubernetes Cluster local.


No nosso caso utilizamos o minikube, mas pode ser feito com o Kind também.
Basta rodar o comando:
```
minikube start
```

ou

```
kind start cluster
```

### Instalar o istioclt

O istioctl é uma ferramenta de linha de comando que permite configurar o istio dentro do kubernetes cluster.

Link para instalar o istioclt [aqui](https://istio.io/latest/docs/setup/install/istioctl/). Uma vez instalado é possivel testar com o comando:
```
istioctl version
```

Com o istioclt está baixado, é necessário instalar ele dentro do kubernetes cluster criado com o minikube. Basta rodar o comando:
```
istioctl install -y 
```

### Criar um Istio Gateway
Para que o Seldon Core use os recursos do Istio para gerenciar o tráfego do cluster, precisamos criar um Istio Gateway executando o arquivo "istio_config.yaml": 

```
kubectl apply -f istio_config.yaml
```
### Instalar Seldon Core no kubernetes cluster.
1. Criando um namespace chamado de seldon-system: 

```
kubectl create namespace seldon-system
```
2. Em seguida rodar o comando helm para instalar o seldon core usando Istio
```
helm install seldon-core seldon-core-operator --repo https://storage.googleapis.com/seldon-charts --set usageMetrics.enabled=true --namespace seldon-system --set istio.enabled=true
```


3. Checando se o Seldon Controller está rodando:
```
kubectl get pods -n seldon-system
```
Deve existir um pod chamado seldon-contoller-manager com STATUS=Running. As vezes ele pode demorar um pouco para rodar.

### Realizar o deploy do modelo


1. Criando um namespace para fazer o deployment da inferência (Nesse caso criei com o nome seldon, mas qualquer nome é valido):
```
kubectl create namespace seldon
```
2. Fazendo deploy do  modelo por meio de um YAML file. 

**Como utilizaremos uma imagem custom com o modelo PyTorch, é necessario substituir o nome da imagem no arquivo "seldon-deployment.yaml" antes de rodar o comando a baixo.**
```
kubectl apply -f seldon_deployment.yaml
```
3. Verifique se o pod está criado

````
kubectl get pods -n seldon
````

Deve existir um pod no estado "ContainerCreating". Nesse momento o pod está baixando a imagem docker e construindo um container. Quando o pod estiver no estado "Running" o serviço deve estar funcional.

### Testando a inferência do modelo.

Como o cluster kubernetes está sendo executado localmente, precisamos encaminhar uma porta em sua máquina local para uma no cluster para que possamos acessá-la externamente. Você pode fazer isso executando:

```
kubectl port-forward -n istio-system svc/istio-ingressgateway 8080:80
```

Então acessar a API por meio do link:
```
http://<ingress_url>/seldon/<namespace>/<model-name>/api/v1.0/doc/
```
No nosso caso o link ficou: 
```
http://localhost:8080/seldon/seldon/aquiles/api/v1.0/doc/
```












