Crear una función en Python para desplegar en OpenFaas (2/2)
Tags: python, openfaas, spanish
Published: 2022-08-06 00:35:00

Lo primero que necesitamos es el cliente de Open Faas “faas-cli” para lo cual podemos escoger desde su página los diferentes binarios [CLI Install](https://docs.openfaas.com/cli/install/)

En mi caso y para este ejemplo lo realizaré en Windows, para descargar el cliente lo primero es obtener la versión última del cli:

```sh
$version = (Invoke-WebRequest "https://api.github.com/repos/openfaas/faas-cli/releases/latest" | ConvertFrom-Json)[0].tag_name
```

Y ahora descargamos el ejecutable de acuerdo a la última versión:
```sh
(New-Object System.Net.WebClient).DownloadFile("https://github.com/openfaas/faas-cli/releases/download/$version/faas-cli.exe", "faas-cli.exe")
```
Podríamos agregar como variable de entorno en la ruta PATH para poder acceder a él sin necesidad de invocar toda la ruta o sino utilizarlo mediante la ruta absoluta del ejecutable.

En el blog anterior hable sobre la instalación de OpenFaas en el cual al finalizar se obtiene el password del servidor para poder ingresar

https://dev.to/jevillanueva/openfaas-con-k3s-en-un-servidor-arm64-2ib2

Ese password guardaremos en un archivo para poder iniciar sesión  llamado “password.txt” esta es una forma de realizar el login, posteriormente conectamos utilizando el archivo “password.txt” apuntando al gateway de openfaas

```sh
cat .\password.txt | faas-cli.exe login -s --gateway https://faas.jevillanueva.dev
```
Nos generará las credenciales para nuestro usuario almacenado en la carpeta de “usuarios/.openfaas”.

Fass cli, nos permite gestionar las imágenes de docker para ser cargadas a openfaas, utilizando build, push, deploy y up.

Existe muchas opciones para deployar cuenta con una variedad de [templates](https://docs.openfaas.com/cli/templates/)

Para esta guía utilizaremos python

faas-cli new echo --lang python3


![Crear Funcion](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/s2mveudx6xcfc5xgxrcw.png)

Genera una estructura de proyecto similar a esta


![Estructura Proyecto](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/co9zabhuil2pvkmohwdt.png)

En el archivo handler.py se encuentra el request que se recibirá cuando esté en línea
```py
def handle(req):
    """handle a request to the function
    Args:
        req (str): request body
    """
    return req
```
Modificaremos el archivo “echo.yml” con las características de nuestro servidor de openfaas

```yml
#echo.yml
version: 1.0
provider:
  name: openfaas
  gateway: https://faas.jevillanueva.dev/ #Dirección del servidor openfaas
functions:
  echo:
    lang: python3
    handler: ./echo
    image: jevillanueva/echo-openfaas:latest #nombre de la imagen de docker
```
Para estos ejemplos se esta utilizando imágenes públicas para que sea de fácil consumo y deploy utilizando Docker Hub como Container Registry

Realizamos el build 
```sh
faas-cli build -f ./echo.yml
```


Subimos al docker hub
```sh
faas-cli push -f ./echo.yml
```

Una vez compilada y publicada la imagen en el docker hub ya podemos levantar la función en nuestro servidor openfaas

Levantamos la función utilizando
```sh
faas-cli deploy -f ./echo.yml
```
Podemos visualizar desde la página de administración la función e invocar.


![Funcion desplegada](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nmddu897oek71mh8qdgv.png)

Podemos probar nuestro endpoint utilizando postman o un curl
```sh
curl --request GET 'https://faas.jevillanueva.dev/function/echo' --header 'Content-Type: application/json' --data-raw '{"message": "Hola Mundo"}'
```

![Desde Postman](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/a3l9uivb4tfxonlw19go.png)

## EXTRA

Como estamos trabajando sobre Windows en un equipo con Arquitectura de 64 Bits, y el servidor de OpenFaas está sobre ARM64 necesitaremos compilar las imágenes de docker de manera compatible para ARM utilizaremos para esto [Buildx](https://docs.docker.com/build/buildx/), donde nos permitirá otra forma de generar las imagenes y [QEMU](https://www.qemu.org/ ) para virtualizar un entorno ARM. Para lo cual primero debemos descargar las herramientas de QEMU

```sh
docker run --rm --privileged  multiarch/qemu-user-static --reset -p yes
```
Una vez descargadas las herramientas se puede realizar el publish multiarch en docker hub
```sh
faas-cli publish -f ./echo.yml --platforms linux/arm64,linux/amd64
```



El proyecto implementado se encuentra en: 
https://github.com/jevillanueva/echo-openfaas  
https://hub.docker.com/r/jevillanueva/echo-openfaas 

Recursos Utilizados:
https://docs.openfaas.com/cli/install/
https://docs.openfaas.com/cli/templates/ 
https://docs.docker.com/build/buildx/
https://www.qemu.org/

Para ver el post anterior de levantamiento de servidor de Open Faas pueden ver el post anterior 
["OpenFaaS con K3S en un servidor ARM64 (1/2)"](https://dev.to/jevillanueva/openfaas-con-k3s-en-un-servidor-arm64-2ib2)

Ahí les dejo mi página personal [jevillanueva.dev](https://jevillanueva.dev)