Docker is an open platform for developing, shipping, and running applications. It allows you to package an application with all of its dependencies into a standardized unit for software development. In practice, this involves building what is called a Docker image, i.e. the blueprints of the application which form the basis of Docker containers, the content at rest. In order to build this image, we need to define a Dockerfile, i.e. a simple text-file that contains a list of commands that the Docker client calls while creating an image. Once built, the image is stored in a registry (e.g. Container Registry on GCP) and can be deployed on a dedicated instance, via Cloud Run or App Engine for example.<\/em><\/p>\n<\/div>Therefore in our case we have to:<\/p>\n<\/div>
- <\/i><\/span>
\n
Create a Dockerfile<\/p>\n<\/div><\/li>
- <\/i><\/span>
\n
Build our application image<\/p>\n<\/div><\/li>
- <\/i><\/span>
\n
Store the image on a registry<\/p>\n<\/div><\/li><\/ul>
Let\u2019s start with the creation of the Dockerfile. As mentioned before, this consists in a succession of commands used to create the Docker image. In the case of a Streamlit application, the Dockerfile can be divided into several blocks:<\/p>\n<\/div>
- <\/i><\/span>
\n
Define the runtime environment: in our case python 3.7<\/p>\n<\/div><\/li>
- <\/i><\/span>
\n
Define the port on which the application will run<\/p>\n<\/div><\/li>
- <\/i><\/span>
\n
Install the needed libraries and their dependencies using a requirements.txt file<\/p>\n<\/div><\/li>
- <\/i><\/span>
\n
Copy the code of your application and define the working directory from where the application will be launched<\/p>\n<\/div><\/li>
- <\/i><\/span>
\n
Define the command to run the application<\/p>\n<\/div><\/li><\/ul>
\u251c\u2500\u2500 app.py <- Main script to launch the Streamlit app
\n\u251c\u2500\u2500 text_explorer <- Folder gathering all the functions and code
\n\u251c\u2500\u2500 requirements.txt <- File listing needed libraries to install
\n\u2514\u2500\u2500 references <- Folder containing logos and images<\/p>\n<\/div>
With this structure, here is an example of the Dockerfile we used for our application:<\/p>\n<\/div>
\n
FROM python:3.7<\/p>\n
# Expose port you want your app on
\nEXPOSE 8080<\/p>\n
# Upgrade pip and install requirements
\nCOPY requirements.txt requirements.txt
\nRUN pip install -U pip
\nRUN pip install -r requirements.txt<\/p>\n
# Copy app code and set working directory
\nCOPY text_explorer text_explorer
\nCOPY app.py app.py
\nCOPY references references
\nWORKDIR .<\/p>\n
# Run
\nENTRYPOINT [“streamlit”, “run”, “app.py”, “–server.port=8080”, “–server.address=0.0.0.0”]\n<\/div>\n<\/div>
Once the Dockerfile is created, we can build our image, following a GCP-friendly naming convention that will be helpful for the deployment later on. This is done via the following command:<\/p>\n<\/div>
docker build -t eu.gcr.io\/gcp_project_name\/app_name:v1 .<\/div>\n<\/div>
To adapt it to your own application, replace the \u2018gcp_project_name\u2019<\/em> by your own GCP project name and the \u2018app_name\u2019<\/em> by your own application name. You can also update the version number as your application evolves by modifying the \u2018v1<\/em>\u2019 suffix with your current version.<\/p>\n<\/div>From there, with our application packaged in a docker image, we can deploy it on GCP to make it accessible to our teammates.<\/p>\n<\/div>
Deploy your app with Cloud Run<\/h3><\/div>Cloud Run is a GCP serverless cloud service used to easily deploy pre-built applications. One of its main advantages is that it automates most of the resources management process. Therefore, all you have to do is to tell Cloud Run where your Docker image is, and then Cloud Run will deploy it on a serverless environment without needing to specify the optimal number of resources for example.<\/p>\n<\/div>
In order to do that, you can follow the steps listed below:<\/p>\n<\/div>
\n- Initialize gcloud<\/em> module on the right GCP project with the following command:<\/li>\n<\/ul>\n<\/div>
gcloud init<\/p>\n<\/div>
\n- Push the docker to the GCP Container Registry with the following command:<\/li>\n<\/ul>\n<\/div>
docker push eu.gcr.io\/gcp_project_name\/app_name:v1<\/div>\n<\/div>
\n- Go on your GCP project, on the Cloud run section. Click on \u201cCreate service\u201d, choose the region and define your service name. Then, select the Docker image that corresponds to your Streamlit app and update the port with the one you defined in your Dockerfile<\/li>\n<\/ol>\n<\/div>
![\"\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/06\/Cloud-Run-interface.png\")
Cloud Run interface<\/p>\n<\/div>
\n- Finally, you can test your app by following the URL linked to the newly created Cloud Run service<\/li>\n<\/ul>\n<\/div>
As you can see, the deployment is done in just a few steps and is quite easy, even for newcomers to application deployment. However, in our case, on top of the deployment, we also wanted to secure our application so that it would only be accessible within our company and at that time, we did not find any \u201ceasy\u201d solution that would fit with Cloud Run. That is why we decided to look for an alternative solution that would allow us to have this security layer without too much difficulty and we finally ended up with App Engine.<\/p>\n<\/div>
Deploy your app with App Engine<\/h3><\/div>App Engine is a cloud-based computing service used to host web apps that are already in the Google infrastructure. In a nutshell, it allows you to do the same thing as Cloud Run in the sense that they are both Google cloud services that allow you to deploy applications. However, unlike Cloud Run where you only pay for the requests that come in, on App Engine you pay for the entire run time, whether there are requests or not. Thus at the end, App Engine may be a more expensive solution. Despite this, we still decided to go for this solution because App Engine has the advantage of having a native integration with IAP (Identity-Aware Proxy) that allows to easily secure your application.<\/p>\n<\/div>
The steps to achieve a deployment on App Engine are not more numerous nor more complicated than for Cloud Run, here is what you need to do:<\/p>\n<\/div>
\n- Check the port specified in your Dockefile, it has to be 8080 to be compatible with App Engine<\/li>\n<\/ul>\n<\/div>
\n- Initialize gcloud module on the right GCP project with the following command:<\/li>\n<\/ul>\n<\/div>
gcloud init<\/div>\n<\/div>
\n- Create a YAML file for your app (named app.yaml) at the root of your project (i.e. at the same level as your main script and your Dockerfile) with the following template:<\/li>\n<\/ul>\n<\/div>
![\"app.yaml](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/06\/app.yaml-file-example.png\")
app.yaml file example<\/p>\n<\/div>
Update the service name with your own application service name<\/em><\/p>\n<\/div>Here we defined the runtime: custom option because custom runtimes let you build apps that run in an environment defined by a Dockerfile as it is the case for us. The env:flex option means that our application will be run in the flexible environment (by opposition to the standard environment). This choice was made because the flexible environment runs the application in Docker containers on Google Compute Engine virtual machines (VMs), which have fewer restrictions than in the standard environment (e.g. your app cannot write to disk). More details about the key differences are available in the Google documentation.<\/p>\n<\/div>
You can also include more detailed network, resources and scaling settings within the YAML file such as the minimum number of instances given to your service or the number of CPUs for example. You can also define some environment variables in that file to make them accessible to your application.<\/p>\n<\/div>
\n- Run the following command (this could take several minutes):<\/li>\n<\/ul>\n<\/div>
gcloud app deploy app.yaml<\/div>\n<\/div>
\n- Once done with the deploy command, the app will be available on App Engine and you will find its dedicated URL directly on GCP<\/li>\n<\/ul>\n<\/div>
If you want to secure your app and give a restricted access to some people, go to your GCP project, in the \u201cIAM & Admin\u201d \/ \u201cIdentity-Aware Proxy\u201d section:<\/p>\n<\/div>
\n- In \u201cAll Web Services\u201d you should see an \u201cApp Engine app\u201d section. If IAP is off, turn it on and click on your Streamlit service.<\/li>\n<\/ul>\n<\/div>
![\"\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/06\/IAP-sections-to-manage-permissions-1.png\")
![\"\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/06\/IAP-sections-to-manage-permissions-BIS.png\")
<\/p>\n
IAP sections to manage permissions<\/p>\n<\/div>
\n- On the right, click on \u201cAdd member\u201d, enter all the email addresses you want (or an alias linked to a mailing list) and select the \u201cIAP-secured Web App User\u201d role.<\/li>\n<\/ul>\n<\/div>
And you\u2019re done. Your application is now deployed and secured.<\/p>\n<\/div>
Tips if you have trouble with images display in your deployed app<\/h2><\/div>When using st.pyplot() or st.image(), you may encounter some display troubles when looking at your deployed application (i.e. \u201c0\u201d displayed instead of your plot or image). We recommend to use st.plotly_chart() whenever you can to avoid that and to use HTML code snippets otherwise. For example, in our case, we wanted to display some wordclouds and that could not be done with Plotly. Thus we decided to save the wordcloud image as PNG in a dedicated GCS bucket, download it as bytes and display it with some HTML code like this:<\/p>\n<\/div>
def display_wordcloud(image):
\nst.markdown(
\nf\"\"\"<\/p>\n
\n
![](\"data:image\/png;base64,\")
\n<\/div>\n
\n\"\"\",
\nunsafe_allow_html=True
\n)
\nst.markdown(\"\")
\nst.markdown(\"\")<\/div>\n<\/div>
In that example, the variable \u201cimage\u201d is a bytes object coming from the method .dowload_as_bytes() of Google cloud storage python package.<\/p>\n<\/div>
Conclusion<\/h2><\/div>The purpose of this article was to give you some tips and examples of cloud services that can be used for deploying Streamlit applications. In our experience, if you need a security layer to ensure restricted access to some people, App Engine will be the appropriate solution. Otherwise, Cloud Run remains an easy way to deploy a Streamlit application.<\/p>\n<\/div>
Credits: Paul Devienne, Amale El Hamri<\/em><\/p>\n<\/div><\/div><\/div><\/div><\/article><\/p>\n","protected":false},"excerpt":{"rendered":"28 juni 2021
\nStreamlit is een geweldig hulpmiddel om vrij eenvoudig prachtige data toepassingen te maken, maar als het aankomt op het implementeren en toegankelijk maken ervan, kan het ingewikkelder zijn voor niet-specialisten. In dit artikel willen we onze reis naar het implementeren van onze applicatie op GCP presenteren, met beperkte toegang voor specifieke mensen. We hebben twee oplossingen ge\u00efmplementeerd: \u00e9\u00e9n met Cloud Run, de andere met App Engine en we hebben gekozen voor App Engine omdat het zo gemakkelijk is om de applicatie te beveiligen met IAP (Identity-Aware Proxy).<\/p>","protected":false},"featured_media":61423,"parent":0,"template":"","meta":{"_acf_changed":false,"ep_exclude_from_search":false},"blog-category":[22035],"blog-language":[2991],"class_list":["post-61415","blog","type-blog","status-publish","has-post-thumbnail","hentry","blog-category-data-ai-consulting","blog-language-en"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog\/61415","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog"}],"about":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/types\/blog"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/media\/61423"}],"wp:attachment":[{"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/media?parent=61415"}],"wp:term":[{"taxonomy":"blog-category","embeddable":true,"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog-category?post=61415"},{"taxonomy":"blog-language","embeddable":true,"href":"https:\/\/www.artefact.com\/nl\/wp-json\/wp\/v2\/blog-language?post=61415"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/05\/Rafaelle-Aygalenq-300x300.jpeg\")
![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/03\/medium.png\" "\\"medium\\"")
<\/span><\/div>![\"Example](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/06\/Example-of-the-app-that-will-be-deployed-on-GCP.png\")
<\/p>\n