Using Custom Dockerfiles
Find out how to use your own custom Dockerfile with OCI Functions.
When you build or deploy a function with OCI Functions, a Docker image is created and pushed to a Docker registry. As with any Docker image, the instructions to build the image are contained in a Dockerfile.
If the function is written in one of the languages supported by an Fn Project FDK
(Functions Development Kit), OCI Functions uses
run_image: settings in a func.yaml file to determine the language
(and therefore the build-time and run-time dependencies) to include in the Docker image.
If you use the
fn init command to initialize the function, a func.yaml
file is created for you. For example, a func.yaml might look like:
schema_version: 20180708 name: hello-java version: 0.0.1 runtime: java build_image: fnproject/fn-java-fdk-build:jdk11-1.0.116 run_image: fnproject/fn-java-fdk:jre11-1.0.116 cmd: com.example.fn.HelloFunction::handleRequest
When you build or deploy the function, OCI Functions uses the settings in the func.yaml file to create a temporary Dockerfile containing the instructions from which to build the Docker image. For example, a temporary Dockerfile is shown below.
FROM fnproject/fn-java-fdk-build:jdk11-1.0.116 as build-stage WORKDIR /function ENV MAVEN_OPTS -Dhttp.proxyHost= -Dhttp.proxyPort= -Dhttps.proxyHost= -Dhttps.proxyPort= -Dhttp.nonProxyHosts= -Dmaven.repo.local=/usr/share/maven/ref/repository ADD pom.xml /function/pom.xml RUN ["mvn", "package", "dependency:copy-dependencies", "-DincludeScope=runtime", "-DskipTests=true", "-Dmdep.prependGroupId=true", "-DoutputDirectory=target", "--fail-never"] ADD src /function/src RUN ["mvn", "package"] FROM fnproject/fn-java-fdk:jre11-1.0.116 WORKDIR /function COPY --from=build-stage /function/target/*.jar /function/app/ CMD ["com.example.fn.HelloFunction::handleRequest"]
Having created the Docker image, OCI Functions deletes the temporary Dockerfile.
If you want more control over the Docker image that is created, you can modify the Dockerfile that OCI Functions creates. Alternatively, you can create your own Dockerfile entirely from scratch. In both cases, the Dockerfile is referred to as a 'custom Dockerfile'. This workflow is sometimes referred to as Bring-Your-Own-Dockerfile, or BYOD.
When you build or deploy the function, OCI Functions uses the instructions in the custom Dockerfile to build the Docker image.
To have OCI Functions use a custom Dockerfile when building a Docker image:
Make a copy of the Dockerfile you want to use as a custom Dockerfile.
Save the new file to the directory containing the func.yaml file.
Give the new file the name
Note that you must name the file
Open the file named
Dockerfilein an editor of your choice.
For example, the
Dockerfilefile might contain the following lines to install the Oracle Instant Client from an oraclelinux:7-slim base image:
FROM oraclelinux:7-slim RUN yum -y install oracle-release-el7 oracle-nodejs-release-el7 && \ yum-config-manager --disable ol7_developer_EPEL && \ yum -y install oracle-instantclient19.3-basiclite nodejs && \ rm -rf /var/cache/yum WORKDIR /function ADD . /function/ RUN npm install CMD exec node func.js
Include the following lines in the file named
Dockerfile(as described in Permissions Granted to Containers Running Functions):
groupadd --gid 1000 fn && \ adduser --uid 1000 --gid fn fn
FROM oraclelinux:7-slim RUN yum -y install oracle-release-el7 oracle-nodejs-release-el7 && \ yum-config-manager --disable ol7_developer_EPEL && \ yum -y install oracle-instantclient19.3-basiclite nodejs && \ rm -rf /var/cache/yum && \ groupadd --gid 1000 fn && \ adduser --uid 1000 --gid fn fn WORKDIR /function ADD . /function/ RUN npm install CMD exec node func.js
Save the file named
Dockerfile. You can now use the
Dockerfilefile as a custom Dockerfile.
In the func.yaml file, change the value of the
For example, if the func.yaml file contains
runtime: java, change it to
fn deploycommands to build or deploy the function.
OCI Functions uses the instructions in the custom Dockerfile (the file named
Dockerfile) to build the Docker image for the function, and push it to the Docker registry. Using the
fn build or
fn deploy command ensures the image includes the necessary dependencies to make it compatible with the application's shape (see Specifying the Compute Architecture on Which to Run Functions).