FPM controller on fly.io

[Arpita-Jaiswal]

Status: In Progress

Owner: @Heulitig

Started On: 18th October 2022

TODO:

• domain mapping for user-specific domains with fly.io
• payment/transaction API's

4th November

• changed the public IP port from 9000 to default 80 so that the user wont have to explicitly mention the 9000 port after every public IP from which the deployed package could be accessed.
• deployed the controller-service using heulitig/gunicorn-controller docker image at fly.io
• tested deploying packages using this global controller-service which worked before the recent fpm changes, had faced some endpoint related issues later using the latest fpm build, due to some endpoint issues.

3rd November

• Logged into flyctl using proper fly credentials by using env variables prior to proxy tunnelling
• Updated the dockerfile to enable proxy on its local port to the fly API alongside
  running the controller service using gunicorn using a runner script.
• built the controller-service docker and pushed it to docker hub under heulitig/gunicorn-controller

2nd November

• working on deploying the controller-service using a docker image at fly.io
• Had some issues while enabling proxy tunnelling to fly machine API for the controller service inside docker container

1st November

• working on deploying the django controller service using gunicorn instead of using the
  django test service for testing
• did some changes to handle private fly credentials and auth token from seperate
  file local_settings.py which the controller service will use.
• also adjusted the API to delete the existing deployed hosted instance of a user package using this controller

27th October

• controller-service documentation - added prerequisites.ftd, steps-to-run.ftd when using this service with controller-ui

25th October

• created a seperate controller-docs repo to include all documentation
• controller-service documentation for implemented API's and UserPackages model used
  for storing package, instance and user information

21st October

• minor adjustments on controller-ui
• accomodated tracker id (tid) middleware and assigned tid in the browser cookie if not found
• tested out these API's by creating/ deploying test app at fly.io

20th October

• created docker image and deployed that at docker hub
• implemented create-instance API by making POST requests to fly.io Machines API
• implemented and adjusted list-packages API
• allocated global ipv4 to the deployed apps at fly.io

19th October

• finalized controller-ui pages
• created dockerFile to be used on when deploying user package
• did some initial work on list-packages, create-instance, delete-instance API's

18th October

• controller-ui implementation for main index page and create-instance page
• partial work on controller-django service and its integration with the controller-ui pages

---

Tables

The fpm-controller has one table with following structure:

class UserPackages(models.Model):
  class InstanceStatus(models.TextChoices):
        INITIALIZED = "INITIALIZED", "Initialized"
        PENDING = "PENDING", "Pending"
        READY = "READY", "Ready"
        STOPPED = "STOPPED", "Stopped"
        TERMINATED = "TERMINATED", "Terminated"

  tracker = models.CharField()
  package_name = models.CharField(
          unique=True, help_text="name of the FPM package", max_length=255
      )
  download_base_url = models.CharField(
            unique=True, help_text="name of the FPM package", max_length=255
      )
  instance_id = model.CharField(null = True, blank = True, unique = True)
  instance_status = models.CharField(
        help_text="status of EC2 instance, ready, initialized, ect...",
        max_length=127,
        choices=InstanceStatus.choices,
    )
  ip = model.CharField()
  created_at = models.DateTimeField(auto_now_add=True)
  updated_at = models.DateTimeField(auto_now=True)

This model stores the user, package and instance information.

How does it work?

We would have three entries:

• fpm-controller app (fpm), (app.fifthtry.com)
• fpm-controller service (django),
• fpm package instances (fly.io machine)

All the requests will be sent to the app then if the URL is not present in the sitemap, the request will be proxy-passed to the endpoint which, in this case, is the fpm-controller service.

When does the tid get set in the request cookie?

Whenever a request comes to the service which doesn't have tid in the cookie, then, the django middleware (service) will set tid in the cookie.

Pages

• Create an instance page (which is form type page same as kameri app)
• List instances/index page (which shows a list of the instance created by the user with particular tid (instance vs tid map))

API

Create an Instance

URL: /api/create-instance

Request parameters:

• package-name
• download-base-url
• tid
• machine config (CPU, RAM)

Response:

Redirect to index page

This API would create an entry in the UserPackages model and also create and start a fly machine.
The entry would contain the instance_status as PENDING.
To create and start a machine we need to do the following steps:

• Call fly.io to create and start a machine API.
• In this API, we need to pass package-name and download-base-url in the env (environmental variables)
• Also, in this API, we need to pass the docker image which will install the latest fpm in the machine and start the fpm server using fpm serve --download-base-url <download-base-url>.
• Once the machine is up and setup is done, the machine will call the fpm-ready API to fpm-controller service, this API would update the instance_status as READY and set instance_id. (and probably IP too)

Delete an Instance

URL: /api/delete-instance

Request parameters:

• userpackages_id

Response:

Redirect to index page

This API would check for the entry in the UserPackages model and then call the fly.io API to delete the machine permanently. Then, the corresponding entry would change the instance_status to TERMINATED.

List instances

URL: /api/list-instances

Request parameters:

• tid

Response:

[ {
"package_name" : string,
"userpackage_id": int,
"status": string,
"IP": optional string,
}]

This API would return all the packages (probably instances too) against the user. This would simply do a query to the UserPackages model against the tid.

How to create a machine on FLY: https://fly.io/docs/reference/machines/
How to create docker image: https://www.stereolabs.com/docs/docker/creating-your-image/

[Arpita-Jaiswal]

In fpm-docker.dockerfile

FROM ubuntu:latest

WORKDIR app

RUN apt-get update && apt-get install -y curl && apt-get install -y wget

RUN wget https://raw.githubusercontent.com/ftd-lang/fpm-heroku/main/fpm-install.sh

RUN /bin/bash /app/fpm-install.sh

EXPOSE 8000

CMD ["sh", "-c", "/app/fpm serve ${PORT} --bind 0.0.0.0 --download-base-url ${DOWNLOAD_BASE_URL}"]

# docker build -t fpm-docker . --file fpm-docker.dockerfile
# docker run --env PORT=8000 --env DOWNLOAD_BASE_URL=https://raw.githubusercontent.com/AbrarNitk/abrark/main/ -p 8000:8000 -it fpm-docker:latest
# docker stop $(docker container ps -a -q)
# docker rm $(docker container ps -a -q)
# docker rmi $(docker images -a -q)

# docker images
# docker container ps -a
# docker exec -it fc7da85e59c2 /bin/bash
# docker start fc7da85e59c2

[AbrarNitk]

How to Deploy a Docker Image on fly.io

https://github.com/AbrarNitk/fpm-app-config/blob/master/abrark-fpm.dockerfile