Serverless computing … with Pascal
Tags: uncategorized, cloudrun, pascal, serverlesscomputing
Published: 2020-02-03 19:50:27

---
title: Serverless computing … with Pascal
published: true
date: 2019-11-04 22:33:12 UTC
tags: Uncategorized,cloud run,pascal,serverless computing
canonical_url: https://engelke.dev/2019/11/04/serverless-computing-with-pascal/
---

This story is [cross-posted on Medium](https://medium.com/@charles.engelke/serverless-computing-with-pascal-d7a16633db44) as well.

Interested in serverless computing but don’t want to use some newfangled programming language like Python, JavaScript, or Go? Then why not write your serverless web app in [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language))? Let’s go back to the 1970s by taking a Pascal program from the definitive [Pascal User Manual and Report](https://www.springer.com/gp/book/9780387976495), published in 1974, and deploy it to the Google [Cloud Run](https://cloud.google.com/run/) serverless platform. Oh, and here’s a 1970s [background music playlist](https://www.youtube.com/playlist?list=PLGBuKfnErZlAkaUUy57-mR97f8SBgMNHh) to get you focused.

> What’s that?  **You don’t have a need to run serverless Pascal?**  Then maybe you have some other legacy software in only executable form, or a language not widely supported by serverless platforms, or built out of several different apps. The techniques shown here can solve those problems, too.

## Some background

[Google Cloud Functions](https://cloud.google.com/functions/) and similar serverless solutions make it extremely easy to deploy functionality to the cloud. You just write your application code, upload it to the service, and they handle deployment, provisioning, infrastructure, scaling, logging, and security for you. They’re wonderful, but require a trade-off. They will only accept a single program written in one of their supported languages. And Pascal is not (yet?) one of those supported languages.

But [Cloud Run](https://cloud.google.com/run/) provides similar capabilities with a slightly different trade-off. You can use other languages (like Pascal!), executable files, or multiple programs but you need to provide a [container](https://www.docker.com/resources/what-container), not just source code. That’s a little more work, but less than you might think, because [Cloud Build](https://cloud.google.com/cloud-build/) will do it for you. And you get all the normal serverless benefits like automatic scaling (even to zero when your code isn’t running). Let’s see how.

## TL;DR: One-button deployment

The sample [project repository is on GitHub](https://github.com/engelke/cloud-run-pascal). Take a look at it. The  **README**  file is displayed and there’s a big button near the top of it:

![](https://engelkedev.files.wordpress.com/2019/11/button.png?w=286)

If you have a Google Cloud account, such as a Gmail account, you can click that button, answer any prompts it displays, and in a few minutes you will have a running web service built from the Pascal program in the repository. The URL will be displayed when the service is deployed.

You can fork this repository and change it to run your own Pascal code (or, with a little more tweaking, any other code) and launch your own new service the same way. It’s even possible to make the service run at a URL on your own domain.

## How it works

I’ve taken a Pascal program and deployed it to Cloud Run as a web service. It takes a number and returns the same number, but in Roman numerals. Want to see what 1974 (the year the program I’m using was published) looks like in Roman numerals? Just call the RESTful service via [https://roman.engelke.dev/1974](https://roman.engelke.dev/1974) to find out. Or you can put a different number in the URL to convert it. This program doesn’t use Roman numeral shortcuts (like IX for 9) so there can be four of one letter in a row.

To build this from scratch yourself, first create a new folder to hold all the pieces, or simply clone the GitHub repository to a new folder with the command below:

`git clone https://github.com/engelke/cloud-run-pascal.git`

The folder will contain the Pascal program and any other needed pieces to make it work in Cloud Run. First up is [the Pascal program](https://github.com/engelke/cloud-run-pascal/blob/master/roman.pas) itself:

![](https://engelkedev.files.wordpress.com/2019/11/pascal.png?w=799)

Clean and simple, and look: clauses are separated by semicolons and the program ends with a period! Newer languages aren’t so well punctuated. All this program does is read an integer from standard input and write the Roman numeral equivalent to standard output. No modern web technology is needed for that. Which is good, because Pascal is decades older than the web. It’s even older than the Internet Protocol, IP.

The Pascal program doesn’t understand the web, but the container must include a web server. When a web request comes in to Cloud Run, it will run the container and send the request to the web server in it. That web server is provided by a [Python wrapper program](https://github.com/engelke/cloud-run-pascal/blob/master/app.py). The wrapper program doesn’t understand the application, it’s glue software that listens for a web request, pulls the number out of the end of the URL, and runs the Pascal program with that number as its input. If the Pascal program crashes, the wrapper returns a `500 Server Error` message. If the program writes an error message, the wrapper returns a `400 Bad Request` message. Otherwise, the wrapper takes the output of the Pascal program and returns it as the body of the response.

Along with the Python wrapper program there is a [requirements.txt file](https://github.com/engelke/cloud-run-pascal/blob/master/requirements.txt) that specifies which Python libraries are needed by the program. Again, this is just needed to wrap around the real program we need to run, which is in Pascal.

The only other thing needed is [the Dockerfile](https://github.com/engelke/cloud-run-pascal/blob/master/Dockerfile), a text file that tells how to build the container. Let’s take a look at it.

- `FROM python:3.7-slim`  
Build the container on top of a standard one called  **python:3.7-slim**.
- `ENV APP_HOME /appWORKDIR $APP_HOMECOPY . ./`  
Specify where in the container to place the code, and copy the files in the current directory there.
- `RUN pip install -r requirements.txt`As part of building the container, run this command to install the libraries needed by the Python wrapper program.
- `RUN apt-get update -y -qRUN apt-get install -y -q fpcRUN fpc roman.pas`  
Pascal source code can’t be run directly, it must be compiled (converted to a binary executable) first. So, when building the container, these lines say to run commands to install a Pascal compiler called  **fpc**  and then use it to compile the  **roman.pas**  program. The binary executable produced inside the container will be just be called  **roman**.
- `CMD exec gunicorn --bind:$PORT --workers 1 --threads 8 app:app`  
After the container is built and deployed, whenever it is run it should invoke this command, which starts the Python wrapper program and has it listen for web requests on the network port provided by the container.

If you take a look at a basic [Cloud Run quickstart tutorial](https://cloud.google.com/run/docs/quickstarts/build-and-deploy), you’ll see most of these pieces in it. The only new part, which is needed to run the Pascal code, is the three lines that install and then run the Pascal compiler to turn the Pascal source into an executable file.

## Build and deploy

Once you’ve created or cloned a folder with the four needed files:  **roman.pas** ,  **app.py** ,  **requirements.txt** , and  **Dockerfile** , you can deploy it to Cloud Run. You will need a Google account (such as a Gmail account) and you can either [install the Google Cloud SDK](https://cloud.google.com/sdk/install) or your own computer, or use [Cloud Shell](https://cloud.google.com/shell/) (which already has the SDK installed) from inside your browser to run the necessary commands.

Ready? Here are the steps:

1. Go to the [Google Cloud console](https://console.cloud.google.com/) in your browser, and log in if you aren’t already. If this is the first time you’ve used the console you will probably have to agree to terms and conditions.
2. Create a new project by clicking on the drop-down at the top of the page (that will either say “Select a project” or show a selected project) then clicking NEW PROJECT and entering the name you want. Wait a few minutes for the project to be created, then select it from the drop-down at the top of the page.
3. Back at the command line on your computer, or in Cloud Shell, have Google Cloud build your container:  
`gcloud builds submit --tag gcr.io/PROJECT-ID/my-program-name`  
(where `PROJECT-ID` is the one created when you created the project, and `my-program-name` is any name you want to use to describe it). Answer any prompts you are shown — the choices should be clear. This builds your container and saves it in a cloud container repository under your control.
4. Now deploy the container to Cloud Run:  
`gcloud beta run deploy \--image gcr.io/PROJECT-ID/my-program-name \--platform managed`  
You can put the command just on a single long line. Remove the backslashes if you do. Again, answer any prompts displayed.
5. In a few minutes, the command line will display the service URL. You can open it in your browser, but remember to append `/number` to it, for some decimal number, to get the Roman numeral version back.

You now have a 45 year old Pascal program running as a serverless cloud app. Maybe you don’t need that, but some day you might need something else that’s a bit outside what most serverless platforms support, but which you can do in a container. That’s when Cloud Run will pay off for you.

## Final thoughts

Your deployed app’s URL will be provided by Google, but you might want a friendlier option. You can [connect your app to a URL on a domain you own](https://cloud.google.com/run/docs/mapping-custom-domains) if you’d like. It’s a bit tricky, but if you have set up your own domain it shouldn’t pose a problem. I did it, and my Roman numeral service is available at roman.engelke.dev, e.g., [https://roman.engelke.dev/2345](https://roman.engelke.dev/2345).

One of the slowest parts of building the container in this example is installing the Pascal compiler. I could have compiled the Pascal program on my own computer and used the executable instead of the source code in my folder when doing the build. That would let me skip the steps that install the compiler in the container. But since building a container happens rarely, I decided I’d rather be sure that my latest source code was always being used by compiling it as part of that step.

This tutorial uses fully managed Cloud Run, which has Google handle all the work for you. But you can also deploy to [Cloud Run on GKE](https://cloud.google.com/run/docs/gke/setup), either on Google Cloud Platform or even on your own premises, if that’s important for your app.