How to write a function in any language for a similar cost as serverless python or typescript?

[VincentF]

I want to write a function in Java or another language, that is not supported in a code repository that defines Foundry Functions, to run on the ontology and to be called from Workshop.

How can I write a function in any language and call it like any other function in Foundry ?

I want as well the cost of the function to be similar to when I call a function in Typescript or Python in Foundry.

[VincentF]

TLDR: compute module with zero replica

You can use compute module, and yes this won’t acquire resources “all the time” and hence have a comparable cost as a python or typescript function.

In short, you can create a compute module with zero replicas. The first run of a function will be slowed down by the module waking up (10 sec+) but subsequent calls will be doable without much added latency.

Let’s see how to set it up:

1. Create a compute module in functions mode, with or without Ontology API depending on the use-case.
   
   
2. Create a code repo > Compute module > Python or Java.
   
   
   
   Note: You can as well define the content of the container from your local machine and upload it’s image to then run it in the compute module. This is only a quicker example here with Java, given you can create and edit it all in Foundry. If you want to do something else than Python or Java, you will need to follow the tutorial embedded in Compute module to create and upload a container from your local machine
   
   
3. Tag a version
   
   
4. Reference the repository in the compute module
   
   
5. Setup the compute module so that:
   a. It is “persistent” without any timeout for “stopping”
   b. the minimum number of replica is set to be 0 (zero)
   
   
6. Start the compute module, top right
7. Add the function that were auto-detected. In the “Functions” tab you will see the Automatic function detection being filled with functions your compute module exposes. Click “add” on the functions you want to actually expose.
   
   
   
   
   
   
   
   
8. [Optional - for testing] Create a Workshop application where you call the function you created

From there, the behavior will be:

• The compute module will be “always on”
• The replica will start within the compute module (as you just started the compute module) but the replica will be decommissioned after 10m of inactivity (this is not something you can currently configure in the UI).
  
  
• Whenever you call the exposed function in Workshop, the compute module will start a new replica (which will take about 10 seconds), execute the function and return the result. The replica will stay available for 10 minutes and will be decommissioned after that if there hasn’t been new calls.
  
  
  
  
  

The cost is based on the time the replica is running (given this is the replica that pre-empt the resources to execute the function) and hence a compute module without a replica running should not incur a cost by itself.

To recapitulate:

• I want to write a function in python => You can directly do this in platform with a code repository (function > python), and have your function in a serverless mode or deployed mode.
• I want to write a function in typescript => You can directly do this in platform with a code repository (function > typescript V1 or V2), have a “serverless” function or a deployed function.
• I want to write a function in java => You can directly do this in platform with a code repository (Function > Compute Module > Java) have a compute module backed function.
• I want to write a function in <any other language> => You can locally create a container, following the docs directly in the compute module application, upload the container to foundry and launch it with compute module.

[nicornk]

Do you know how to force a cold start on a replica? (Without updating the image)
Is it possible to change a metadata setting to force a cold start?
E.g. In AWS Lambda one can change an environment variable to force a cold start.

[Flackermann]

Hi, I appreciate the small tutorial on this matter
If I understand the documentation correctly, compute modules can have egress rules to other systems e.g. for ingesting data or triggering sideeffects correct?

I would really like to use compute modules to host a custom container that uses the OAuth2Token / Foundry Token to query data from the Vanilla Foundry API and performs some magic related to the usecase before returning the result. We currently do this by hosting the container outside of the platform which isnt ideal and then use an Outbound application that actually authenticates with Foundry itself to use the personal Oauth2 token in the webhook.

I’d love to either be directly able to query the Foundry API from TS/Python functions, or by egressing from the container to our stack and use the token of the person that calls the compute module in a function. This would give me the advantage that I can build logic as extension to the FoundryAPI without having to constantly upgrade OSDKs and re-deploy code when something changes in the ontology just for the sake of adding an Object Type or properties / updating an API name.

Is there any way this would be currently possible? Maybe I am missing something…

[VincentF]

@nicornk - My most straightforward answer would be to call one of the function. This will as a consequence start the replica. You can call the function from Compute module directly as there is a way to query it from there. Would this be an acceptable answer or do you intend to have a specific endpoint or so to “trigger a start of a replica” ?

@Flackermann Yes, you can add Sources to your compute module, and from your code, access the SOURCE_CREDENTIALS environement variable.
Hence you could make a source to Foundry itself, and use a third party app credentials (a service user, with a client id/client secret) to perform API calls towards foundry itself.

There might be a most straightforward solution (e.g. Platform APIs from Python function directly) but I don’t have a better answer top of mind without investigating.

[Flackermann]

Hi @VincentF ,

I’ve seen the option. However, what I would expect to be able to do is to include sources which are based on Outbound applications that use the OAuth2 authorization code grant protocol. I really like the implementation in Action Types, also Foundry being able to store refresh tokens and automatically re-authenticates if required. Unfortunately, these source are constraint to action types with writeback webhooks or sideffects.

Ideally, one could query from Foundry an external source just for data display e.g. seeing the sample status in a LIMS system, or fetching data for display via the Foundry API and row-level security with some additional computation steps involved (also potentially getting data from an external server). I know that there are possibilities to do something like that using slate, but then again, Slate is limited to javascript / OSDK, and not a good environment to test complex logic.

I think it would be crucial to have those options or delivering the best results for a complicated usecase within the platform and also for embedding the platform in our existing landscape.