Create OCI Functionality running a Playwright circumstance – AMIS, Details Pushed Web site

TLDR – How to make a Function on Oracle Cloud Infrastructure that takes advantage of the Playwright library for jogging headless browser situations, for case in point for Website UI Wellbeing Verify and Effectiveness Checking, for tactical integration and uncomplicated RPA and for website centered reporting. The posting reveals a tailor made Docker container impression dependent on a local community container graphic for headless chrome and Playwright with a tailor made Node application that interacts with the Google Translate web ui the Project Fn hotwrap utility is additional to this graphic to deliver the bridge from the OCI FaaS serverless operate framework dependent on Task Fn to the personalized Node software. This tactic can be applied for any Playwright circumstance and also for other personalized Docker container pictures not associated to Playwright.

Sources for this write-up on GitHub:

At the heart of the perform is a Node software that takes advantage of Playwright to interact with the Google Translate World-wide-web UI, enter resource language, focus on language and textual content to translate and reads the translation created by Google Translate. The Perform wants to be implemented with a Docker Container graphic. An Fn image can be developed in three means:

  • the regular tactic: generate a new Fn perform with runtime node in the Fn CLI insert playwright in offer.json and hope it works due to the fact of binary libraries, I fear it will not – and without a doubt it does not
  • customise the Docker Image utilized for creating the Fn container for the Node runtime – dependent on this write-up:   this method much too did not appear to be to operate: incorporating Playwright to this container graphic did not go easily, despite the fact that it almost certainly can be performed
  • create a custom made Docker establish file that extends from an current picture with Playwright increase the Node software and insert HotWrap to supply the bridge in between the Fn FaaS framework and the Node software, following this post: this method labored out perfectly and is not all that sophisticated at all.

The starting up issue for the container that implements the Fn purpose is the image produced by local community job Alpine Chrome challenge on GitHub for *Chrome jogging in headless mode in a very small Alpine picture*: This project creates picture zenika/alpine-chrome:with-playwright. This picture consists of Node, Playwright Chromium and supporting binaries, an great starting off stage.


In my individual graphic, I have to have to incorporate of study course the Node software that utilizes Playwright to interact with the Chromium browser that accesses the Google Translate World wide web UI. On top of that I have to add the HotWrap binary that supplies the bridge at runtime amongst the OCI Functions Fn server framework and the customized code in the container picture for the operate. Hotwrap takes the input from the operate request and can make it readily available to our customized code by using the standard input. Nearly anything the custom application writes to the common output is can take by hotwrap and returned as the function’s reaction. Furthermore, hotwrap tends to make HTTP headers despatched in the perform request out there as atmosphere variables within the container.

The container graphic declares a CMD to determine the startup instruction for the Node application that does the true get the job done and a closing ENTRYPOINT that be certain that hotwrap is key system begun when the container is begun. The Dockerfile appears like this:


In Node software app.js I have to cater for the interaction with Hotwrap. The enter to the Fn purpose is intercepted by Hotwrap and made accessible to the Node code via the typical input. The end result from the Node application requirements to be written to the typical output in get for Hotwrap to eat it and convert it into the Response overall body from the Fn perform. The app.js code is produced like this:


The true operate is carried out in translate.js. The code in translate.js is not aware of Hotwrap or Fn or the Docker container context. You will come across its code in the GitHub repo.

Techniques for producing the perform are now uncomplicated, for illustration as a result of OCI Cloudshell or in any Fn CLI environment:

1. Create a new listing that will comprise the function’s resources. Copy these data files to this new directory:

  • Dockerfile
  • func.yaml
  • application.js
  • translate.js


Execute the following commands from within the new directory

2. Construct and deploy the perform to the software (and the container as well to the registry) Here I have assumed an current Fn software identified as lab1

fn deploy –app lab1


To confirm, checklist the features in software lab1:

fn list capabilities lab1

3. Invoke the perform:

echo -n ‘“sourceLanguage”:”en”, “targetLanguage”:”fr”, “text”:”Hello World”’ | fn invoke lab1 playwright –content-sort application/json


The complete implementation is visualized next:


Of class, this strategy with hotwrap can be employed for functions executed on major of any base container picture:



Resources for this article on GitHub:

Undertaking Household for Fn hotwrap:

Short article on employing hotwrap on best of a extremely simple customized Docker container

Alpine Chrome challenge on GitHub for *Chrome running in headless manner in a very small Alpine image*:

Alpine Chrome on Docker Hub – with photographs for managing Playwright purposes:

Report on Medium “Crafting the excellent container to enjoy with a Headless Chrome”

Microsoft’s Offical P


WSL2 file method is uncovered in Windows Explorer at: wsl$


Post Author: BackSpin Chief Editor

BackSpin Chief Editor
We are the editorial staff at BackSpin Records. We love music, technology, and other interesting things!

Leave a Reply

Your email address will not be published. Required fields are marked *