Deploy your apps to a supercloud in a few clicks

This Engineering Education program is supported by Section. Instantly deploy your GitHub apps, Docker containers or K8s namespaces to a supercloud.

Try It For Free

Deploying a Simple Streamlit app using Docker

June 30, 2021

Docker is a virtualization platform that is designed to create, run, and deploy applications through the use of containers. We will use Docker to deploy a simple machine learning app built using Streamlit.

In this tutorial, we will first create a simple machine learning model, save it into a pickle file to be loaded into our platform, and create its interface using Streamlit. After creating the Streamlit app, we shall use docker to deploy it.

Table of contents


  1. A good understanding of Python.
  2. Good working knowledge of machine learning models.

Building a simple machine learning model

Let’s start by building a simple machine learning prediction model. We will build a machine learning model to predict the gender of a person based on the user’s input.


We will use a dataset of names commonly used by people. The format of our data used is as shown:

A Snip of the data

CSV File

Installation of the required packages

We need the following packages:

  1. Sckit-learn
  2. Pandas
  3. Numpy

The following command is used to install the packages above.

pip install sklearn
pip install pandas
pip install numpy

Importing Panda and Numpy

import pandas as pd
import numpy as np

Importing from sckitlearn

import CountVectorizer from sklearn.feature_extraction.text
import DictVectorizer from sklearn.feature_extraction
df = pd.read_csv('dataset.csv')

Checking for missing values

We need to ensure that there are no missing values in our dataset. This provides well structured data that will optimize on training our model.


Checking for number of male and female

Here, we look for the total number of male and female in our dataset.

df[ == 'F'].size
df[ == 'M'].size
df_names = df

Replacing the data F and M with 0 and 1

This is done so as to provide a binary output of either 0 or 1, 0 to represent female, 1 to represent male.{'F':0,'M':1},inplace=True)
Xfeatures =df_names['name']

Feature extraction

cv = CountVectorizer()
X = cv.fit_transform(Xfeatures)

Processing of model

import train_test_split from sklearn.model_selection

Features and labels

After identifying our features and labels to be used in training the model, we can split our data set into two:

  1. Training set: This will be 75% of the data.
  2. Test Set: This will be 25% of the data.
y =
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)

Creating the naive bayes classifier model

We import Naive Bayes Classifier algorithm from the scikit-learn package. The model will be used to fit and train our model.

import MultinomialNB from sklearn.naive_bayes
clf = MultinomialNB(),y_train)

Making predictions

We will use a function named predict that will be used to predict the gender of a person based on the name provided.

def predict(a):
    test_name = [a]
    vector = cv.transform(test_name).toarray()
    if clf.predict(vector) == 0:

Saving the model into a pickle file

We shall save our model using Joblib. We shall accomplish this by converting our model into a byte stream which will be saved into a pickle file named ’naivemodel.pkl'.

import joblib from sklearn.externals
naiveBayesModel = open("model/naivemodel.pkl","wb")

Introduction to streamlit

Streamlit is a framework that is used by different machine learning engineers and data scientists to build UIs and powerful machine learning apps from a trained model.

These apps can be used for visualization by providing interactive interfaces for the user.

They provide an easier way to build charts, tables, and different figures to meet your application’s needs. They also utilize the models that have been saved or picked into the app to make a prediction.

How to install streamlit

Use the following command:

pip install streamlit

Let’s build the streamlit app

  1. Create a new Python file named
  2. Add our pickled model into a created folder called ‘model’.

Our folder structure should look like this.

├── model
   ├── naivebayesgendermodel.pkl
  1. Import required packages.
import streamlit as st

from sklearn.externals import joblib
import time
from PIL import Image
  1. Unplick the model.

This will help to load our model so that it can be used for gender prediction. Here, the byte stream from the ’naivemodel.pkl’ file is converted into an object hierarchy so that it can be used by the streamlit app.

gender_nv_model = open("models/naivemodel.pkl","rb")
gender_clf = joblib.load(gender_nv_model)
  1. Building our prediction logic.
def predict_gender(data):
  vect = gender_cv.transform(data).toarray()
  result = gender_clf.predict(vect)
  return result
  1. Styling the app We will use material UI for styles and icons for our app.
def load_css(file_name):
    with open(file_name) as f:
        st.markdown('<style>{}</style>'.format(, unsafe_allow_html=True)

def load_icon(icon_name):
    st.markdown('<i class="material-icons">{}</i>'.format(icon_name), unsafe_allow_html=True)
  1. Adding an image
def load_images(file_name):
  img =
  return st.image(img,width=300)

Your file structure should be as shown:

├── male.png
├── female.png
├── model
   ├── nainvemodel.pkl

Designing the user interface

This is where we use different tools from streamlit to design a nice UI.

def main():
  """Gender Classifier App
    With Streamlit


  st.title("Gender Classifier")
  html_temp = """
  <div style="background-color:blue;padding:10px">
  <h2 style="color:grey;text-align:center;">Streamlit App </h2>


  name = st.text_input("Enter Name","Pleas Type Here")
  if st.button("Predict"):
    result = predict_gender([name])
    if result[0] == 0:
      prediction = 'Female'
      img = 'female.png'
      result[0] == 1
      prediction = 'Male'
      img = 'male.png'

    st.success('Name: {} was classified as {}'.format(name.title(),prediction))

The code is explained below:

  • Adding the apps title.
  • Styling our app by adding the app’s background color, text color, and the general structure of our app.
  • Adding a text input area where a user can key in a name to be predicted as either male or female.
  • Adding a button that a user can use to submit the input.

We set the following styles on our app:

Background-color: blue
Text color: grey,
Padding: 10px,
App Title: Gender Classifier App

We then run our app using this command.

streamlit run

Our user interface is as shown below.

  1. A prediction where the output is male.

Male Prediction

  1. Prediction where the output is female

Female Prediction

Dockerizing the streamlit app

  1. Let’s create a Docker file.
  • In the working root directory, let’s create a file named ‘Dockerfile’ without any extensions.

  • Your file structure should be as shown.

├── Dockerfile
├── male.png
├── female.png
├── model
   ├── nainvemodel.pkl
  1. Docker Layers
  • Firstly we define our base image where we want to build our file from, as demostrated below.
FROM python:3.7
  • Here we will use the official Python imge from Docker.

  • Create a working directory as shown.

  • Copy all the requirements into the new directory created.
COPY requirements.txt ./requirements.txt
  • Copying from the source to the destination.

  • Install all that is in the requirments.txt file.

RUN pip install -r requiremts.txt
  • Expose the port to be used to run the application.
  • This is the same port that our streamlit app was running on.

  • Copy our app from the current directory to the working area.

COPY ./app
  • Create an entry point to make our image executable.
ENTRYPOINT ["streamlit", "run"]

CMD [""]
  1. Building a Docker image
  • We build using the following command then “.” to run the current directory.
docker build -t streamlitapp:latest .
  • You can also use the following command to specify the file.
docker build -t streamlitapp:latest .f Dockerfile
  • The output will be as shown below.
Sending building context to the Docker daemon  34.90kb
Step 1/8 : FROM python:3.8
Step 2/8 : WORKDIR /app
  --->Using Cache
Step 3/8 : COPY requirements.txt ./requirements.txt
    --->Using Cache
Step 4/8 : RUN pip install -r requiremts.txt
    --->Using Cache
Step 5/8 : EXPOSE 8501
    --->Using Cache
Step 6/8 : COPY ./app
Step 6/8 : EXPOSE 8501
Step 7/8 : ENTRYPOINT ["streamlit", "run"]
Removing intermediate container 5ta3824edte
 ---> 65dv092efstfu
step 8/8 : CMD [""]
Successfully built 65dv092efstfu
Successfully tagged streamlitapp:latest
  • Use the following command to view all your images.
docker image ls
  • Output is as shown.
REPOSITORY                   TAG                 IMAGE ID            CREATED             SIZE
streamlitapp                 latest             65dv092efstfu        2 minutes ago       1.24GB
testapp                      latest             d660b1f1t3e         1 weeks ago          794MB
  1. Creating a container
docker run -p 8501:8501 streamlitapp:latest



It also starts our streamlit app in the following urls:

  1. Network URL:
  2. External URL:

With that, the Streamlit app is now deployed with docker.


In this tutorial, we have learned how to create a simple machine learning model, how to create a steamlit app using the model and finally used Docker to run the app.

We first began by building a gender classification model using our machine learning model. After building the model we designed a user interface using streamlit. Streamlit is a good library used by most developers when building machine learning apps within a short time frame.

Streamlit designs a user interface that the end-user can use to make a prediction of gender based on the name the user has provided.

After we made sure that our streamlit app was fully functional, we finally deployed to docker by creating a docker image. We then used that image to create a docker container, and finally run our app.

By using these steps, a reader should be able to comfortably deploy a streamlit app using Docker.

Happy coding!


Peer Review Contributions by: Peter Kayere