Phil Chen https://philchen.com Phil Chen Wed, 13 Nov 2024 17:58:21 +0000 en-US hourly 1 https://wordpress.org/?v=6.7.5 Building an Asynchronous GenAI Image Generator API https://philchen.com/2024/10/10/building-a-asynchronous-genai-image-generator-api/ Fri, 11 Oct 2024 01:00:20 +0000 https://philchen.com/?p=2291 This article will cover building an asynchronous GenAI image generator API, leveraging Amazon Bedrock Titan Image Generator v2. The API creates asynchronously four unique images based on your prompt and stores them in S3. Generating the images asynchronously allows for a faster processing of multiple images. The API will accept an HTTP POST request with […]

The post Building an Asynchronous GenAI Image Generator API first appeared on Phil Chen.

]]> This article will cover building an asynchronous GenAI image generator API, leveraging Amazon Bedrock Titan Image Generator v2. The API creates asynchronously four unique images based on your prompt and stores them in S3. Generating the images asynchronously allows for a faster processing of multiple images. The API will accept an HTTP POST request with the requested images and file name and folder location.

AI Image Generator API Process Flow

API Overview:

      Create a POST request to the /generate_images endpoint, that has prompt, output_folder and file_name_prefix.

      • prompt is the description of the image you want generated.
      • output_folder is the folder path to the image files, part of the S3 key.
      • file_name_prefix is the name of the image file which will end up with a Unix epoch timestamp appended to it, part of the S3 key.
        Example POST request BODY:

        {"prompt": "red porsche", "output_folder": "000/111", "file_name_prefix": "porsche_image"}

      Four unique images will be generated based on your prompt and uploaded to the S3 bucket you specify in image_generation.py under AI_S3_BUCKET_NAME

      You will get a JSON manifest of file names after the images are generated.

        Example POST request Response:

        {"images": ["000/111/porsche_image-1728409676.376359.png", "000/111/porsche_image-1728409676.376369.png", "000/111/porsche_image-1728409676.376371.png", "000/111/porsche_image-1728409676.3763719.png"]}

    Code:

    Prerequisites:

    • Amazon Web Services Account
    • Enable Amazon Bedrock Access (Specifically Amazon Titan Image Generator v2) see: Manage access to Amazon Bedrock foundation models.
    • EC2 Instance Role with AmazonBedrockFullAccess and AmazonS3FullAccess applied to your EC2 instance (note you can make this more secure by making a custom policy).
    • Verified on EC2 Instance Ubuntu 22.04 and Ubuntu 24.04
    • Verified on Python 3.10, 3.11, 3.12
    • Virtualenv
    • AWS Default Region is set to us-east-1 you can change the region in the image_generation.py file under region_name='us-east-1'
    • AWS S3 bucket

    AWS Resource Costs
    As with most AWS services you will incur costs for usage.

  • https://aws.amazon.com/bedrock/pricing/
  • https://aws.amazon.com/ec2/pricing/on-demand/

Step 0
Install some dependencies

Copy Code 



sudo apt -y update

sudo apt -y install build-essential openssl

sudo apt -y install libpq-dev libssl-dev libffi-dev zlib1g-dev

sudo apt -y install python3-pip python3-dev

sudo apt -y install nginx

sudo apt -y install virtualenvwrapper

Step 1
Setup the Python environment

Copy Code 


cd /home/ubuntu

virtualenv ai-image-generator_env

source ai-image-generator_env/bin/activate

Step 2
Create a directory for your project.

Copy Code 


mkdir /home/ubuntu/ai-image-generator

cd /home/ubuntu/ai-image-generator

Step 3
Create a file requirements.txt for your Python dependencies.

Copy Code 


vim requirements.txt

Copy Code 


boto3
botocore
Pillow
watchdog
requests
flask
flask-json
gunicorn
setproctitle
Copy Code 


pip install -r requirements.txt

Step 4
Create a file image_generation.py which has image generation code.

Copy Code 


cd /home/ubuntu/ai-image-generator

vim image_generation.py

Make sure you put the S3 bucket you want to use in the AI_S3_BUCKET_NAME section.
Copy Code 


import io
import os
import base64
import json
import random
import boto3
from PIL import Image

AI_S3_BUCKET_NAME = "YOUR_S3_BUCKET_NAME_HERE"
AI_IMAGE_GENERATOR_TMP_PATH = "/tmp/ai_image_generator/"
NEGATIVE_PROMPTS = "poorly rendered, poor background details"

# Set Titan generative AI image generation settings.
def ai_image_settings(prompt):

    # Unique AI image random seed generation.
    random_seed = random.randint(0,2147833647)

    body = {
                "taskType": "TEXT_IMAGE",
                "textToImageParams": {
                "text": prompt,                    # Required
                "negativeText": NEGATIVE_PROMPTS   # Optional
             },
            "imageGenerationConfig": {
            "seed": (random_seed), # Range: 0 to 214783647
            "numberOfImages": 1,   # Range: 1 to 5
            "quality": "premium",  # Options: standard or premium
            "height": 1024,        # Supported height list in the docs
            "width": 1024,         # Supported width list in the docs
            "cfgScale": 9          # Range: 1.0 to 10.0
            }
    }

    json_string = json.dumps(body, indent=4)
    return json_string

# AI Image generation and storage.
def ai_image_generation(prompt, local_file_name, output_folder):

    # Invoke Amazon Titan image generator v2.
    boto3_bedrock = boto3.client('bedrock-runtime', region_name='us-east-1')
    ai_model = boto3_bedrock.invoke_model(
        body=ai_image_settings(prompt),
        modelId="amazon.titan-image-generator-v2:0",
        accept="application/json",
        contentType="application/json"
    )

    # Process the AI image Base64.
    response_body = json.loads(ai_model.get("body").read())
    image_base64 = response_body["images"][0]

    # Decode Base64 bytes and save image.
    ai_image = Image.open(
        io.BytesIO(
            base64.decodebytes(
                bytes(image_base64, "utf-8")
            )
        )
    )

    ai_image.save(f"{AI_IMAGE_GENERATOR_TMP_PATH}/{output_folder}/{local_file_name}")

    # Store images in S3.
    s3 = boto3.client('s3')
    bucket = AI_S3_BUCKET_NAME
    file_name = (f"{AI_IMAGE_GENERATOR_TMP_PATH}/{output_folder}/{local_file_name}")
    key_name = os.path.join(output_folder, local_file_name)
    s3.upload_file(file_name, bucket, key_name, ExtraArgs={'ContentType': "image/png"})

    # Delete temporary local copy.
    os.remove(f"{AI_IMAGE_GENERATOR_TMP_PATH}/{output_folder}/{local_file_name}")

# Local cleanup function.
def delete_files_in_directory(directory_path, rm_dir=False):
    try:
        files = os.listdir(directory_path)
        for file in files:
            file_path = os.path.join(directory_path, file)
            if os.path.isfile(file_path):
                os.remove(file_path)

        if (rm_dir):
            os.rmdir(directory_path)

        print("All image files deleted successfully.")
    except OSError:
        print("Error occurred while deleting image files.")

Step 5
Create a file ai_image_generator.py which has the Flask routing code and logic.

Copy Code 


cd /home/ubuntu/ai-image-generator

vim ai_image_generator.py

Copy Code 


import os
import json
import time
import concurrent.futures
from flask import Flask, request
from flask_json import FlaskJSON, JsonError, json_response
from image_generation import ai_image_generation, delete_files_in_directory

AI_IMAGE_GENERATOR_TMP_PATH = "/tmp/ai_image_generator/"

ai_image_generator = Flask(__name__)
FlaskJSON(ai_image_generator)

# 500MB Upload File Size Limit
ai_image_generator.config['MAX_CONTENT_PATH'] = 500 * 1024 * 1024

# Data validations.
def ai_image_generator_data_validation(request_data):
    try:
        prompt = str(request_data['prompt'])
    except (KeyError, TypeError, ValueError) as e:
        raise JsonError(description='Invalid prompt.') from e
    try:
        output_folder = str(request_data['output_folder'])
    except (KeyError, TypeError, ValueError) as e:
        raise JsonError(description='Invalid output_folder.') from e

    try:
        file_name_prefix = str(request_data['file_name_prefix'])
    except (KeyError, TypeError, ValueError) as e:
        raise JsonError(description='Invalid file_name_prefix.') from e

    return prompt, output_folder, file_name_prefix

# Health check route.
@ai_image_generator.route("/")
def health():
    return json_response(health="true")

# Generate images route.
@ai_image_generator.route('/generate_images', methods=['POST'])
def generate_images():
    request_data = request.get_json(force=True)
    prompt, output_folder, file_name_prefix = ai_image_generator_data_validation(request_data)

    output_path = os.path.join(AI_IMAGE_GENERATOR_TMP_PATH, output_folder.strip())

    # Checks if output folder exists, makes one if not. Delete files in folder if it does exist.
    if not os.path.exists(output_path):
        os.makedirs(output_path)
    else:
        delete_files_in_directory(output_path)

    #  Use a pool of threads to execute generation of 4 images asynchronously.
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = []

        file_name = [(f"{file_name_prefix}") + "-" + str(time.time()) + ".png", (f"{file_name_prefix}") + "-" + str(time.time()) + ".png", (f"{file_name_prefix}") + "-" + str(time.time()) + ".png", (f"{file_name_prefix}") + "-" + str(time.time()) + ".png"]
        for file in file_name:
            futures.append(executor.submit(ai_image_generation, prompt=prompt, local_file_name=file, output_folder=output_folder))
        for future in concurrent.futures.as_completed(futures):
            print(future.result())

    # Return JSON output of location/files generated.
    keys = []
    for file in file_name:
        keys.append((os.path.join(output_folder, file)))

    manifest = {"images": keys}

    return json.dumps(manifest)

if __name__ == "__main__":
    ai_image_generator.run(host='0.0.0.0')

Step 6
Create your wsgi.py webserver gateway interface for the Flask microframework

Copy Code 


vim /home/ubuntu/ai-image-generator/wsgi.py

Copy Code 


from ai_image_generator import ai_image_generator
 
if __name__ == "__main__":
    ai_image_generator.run()

Step 7
Create a file gunicorn_ai-image-generator.conf which will be the configurations Gunicorn will utilize. Gunicorn is a Python WSGI HTTP Server for UNIX. For more information about Gunicorn read here.

Copy Code 


cd /home/ubuntu/ai-image-generator

mkdir gunicorn

cd gunicorn

vim gunicorn_ai-image-generator.conf

Add the following to gunicorn_ai-image-generator.conf

Copy Code 


pidfile = 'ai_image_generator.pid'
worker_class = 'gthread'
workers = 5
worker_connections = 1000
timeout = 30
keepalive = 2
threads = 2
proc_name = 'ai_image_generator'
bind = '0.0.0.0:8080'
backlog = 2048
accesslog = 'access.log'
errorlog = 'error.log'
user = 'ubuntu'
group = 'ubuntu'

Step 8
Create a Systemd service file. Systemd is a service manager and in this use case it will manage Gunicorn.

Copy Code 


sudo vim /etc/systemd/system/ai-image-generator.service

Add the following to ai-image-generator.service

Copy Code 


[Unit]
Description=AI Image Generator API
After=network.target
 
[Service]
User=ubuntu
Group=ubuntu
WorkingDirectory=/home/ubuntu/ai-image-generator
Environment="PATH=/home/ubuntu/ai-image-generator_env/bin"
ExecStart=/home/ubuntu/ai-image-generator_env/bin/gunicorn --config=gunicorn/gunicorn_ai-image-generator.conf wsgi:ai_image_generator
 
[Install]
WantedBy=multi-user.target

Step 9
Start your application via Systemd and enable it to auto start after reboot

Copy Code 


sudo systemctl start ai-image-generator

sudo systemctl enable ai-image-generator.service

Step 10
Create your applications NGINX config nginx_ai-image-generator.conf that makes NGINX listen on port 80 and proxies requests to Gunicorn on port 8080. NGINX will help with connection handling increasing performance.

Copy Code 


sudo vim /etc/nginx/sites-available/nginx_ai-image-generator.conf

Add the following to nginx_ai-image-generator.conf

Copy Code 


server {
    listen 80 default_server;

    location / {
        include proxy_params;
      	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP	$remote_addr;
      	proxy_set_header Host $http_host;
      	proxy_redirect off;
        proxy_buffers 8 24k;
        proxy_buffer_size 4k;
        proxy_pass http://127.0.0.1:8080;
    }
}

Step 11
Delete your default NGINX conf file, enable your new NGINX conf and restart NGINX

Copy Code 


sudo rm /etc/nginx/sites-enabled/default

sudo ln -s /etc/nginx/sites-available/nginx_ai-image-generator.conf /etc/nginx/sites-enabled

sudo systemctl restart nginx

Step 12
Time to test your API! From a command line you can test the API out by running:

Copy Code 


curl -X POST --data '{"prompt": "red porsche", "output_folder": "000/111", "file_name_prefix": "porsche_image"}' http://{yourhost}:80/generate_images

Notes:

  • Make sure to open up port 80 in your EC2 Security Group associated to the instance.
  • For HTTPS (TLS) you can use AWS ALB or AWS CloudFront
  • This AI Image Generator API service does not take into consideration security controls, that is your responsibility.
  • Please read Amazon Bedrock FAQ’s for general questions about AWS LLM resources used.

    • Summary:

    Hopefully this blog article helps you create a robust scalable AI driven image generation API. The idea is that a UI/UX of your design will leverage this API to display four images for the end user to choose from. Images will be generated at the same time so all four images will take the same amount of time as one image. The parameters allow for storage in some form of hierarchy with a folder path, and each image will have a unix epoch timestamp. An example structure could be account-number/project-number/file-name. The API will generated a JSON response with where the images are located in S3 for your UI/UX to handle.

    If you like this blog article you may want to read my other article on Building a GenAI PDF Query App with a RAG Architecture.

    The post Building an Asynchronous GenAI Image Generator API first appeared on Phil Chen.

    ]]>         Building a GenAI PDF Query App with a RAG Architecture https://philchen.com/2024/09/19/building-a-genai-pdf-query-app-with-a-rag-architecture/ Thu, 19 Sep 2024 18:00:15 +0000 https://philchen.com/?p=2170 This article will cover building a Generative AI PDF query web application that uses a retrieval-augmented generation (RAG) architecture. The PDF query web application will go through your PDF’s and provide you responses to your questions based on what is in your PDF’s. The importance of using RAG is the ability to scope the results […]

    The post Building a GenAI PDF Query App with a RAG Architecture first appeared on Phil Chen.

    ]]>     This article will cover building a Generative AI PDF query web application that uses a retrieval-augmented generation (RAG) architecture. The PDF query web application will go through your PDF’s and provide you responses to your questions based on what is in your PDF’s. The importance of using RAG is the ability to scope the results of the generated response from the LLM in our case Claude 3.5 Sonnet with up-to-date, accurate, reliable responses. RAG allows for domain-specific contextually relevant responses tailored to your data rather than static training data.

    The PDF query web application will leverage Facebook AI Similarity Search (FAISS) and Amazon Titan Embeddings to create vector representations of unstructured text and the storage/search of those embeddings. LangChain is utilized for the prompt template guiding the models response, RetrievalQA for pertinent data, and various PDF processing tools. We will use Amazon Bedrock to access Claude 3.5 Sonnet and Amazon Titan Embeddings.

    PDF Query RAG-Based LLM GenAI Web Application Process Flow

    Code:

    GitHub repo with files referenced in this blog pdf-query-rag-llm-app

    Prerequisites:

    • Amazon Web Services Account
    • Enable Amazon Bedrock Access (Specifically Amazon Titan Embeddings and Claude 3.5 Sonnet) see: Manage access to Amazon Bedrock foundation models
    • EC2 Instance Role with AmazonBedrockFullAccess Policy Attached (note you can make this more secure by making a custom policy)
    • Verified on EC2 Instance Ubuntu 22.04 and Ubuntu 24.04
    • Verified with Python 3.10, 3.11, 3.12
    • Virtualenv
    • AWS Default Region is set to us-east-1 you can change the region in the pdf_query_rag_llm_app.py file under region_name='us-east-1'

    AWS Resource Cost:

    As with most AWS services you will incur costs for usage.

    EC2 Ubuntu Instance Setup:
    (This article assumes you have a ubuntu user with /home/ubuntu)

    Step 0
    Install some dependencies.

    Copy Code 
    

    
sudo apt -y update

sudo apt -y install build-essential openssl

sudo apt -y install libpq-dev libssl-dev libffi-dev zlib1g-dev

sudo apt -y install python3-pip python3-dev

sudo apt -y install nginx

sudo apt -y install virtualenvwrapper

    Step 1
    Setup the Python environment.

    Copy Code 
    

    cd /home/ubuntu

virtualenv pdf-query-rag-llm-app_env

source pdf-query-rag-llm-app_env/bin/activate

    Step 2
    Create a directory for your project.

    Copy Code 
    

    mkdir /home/ubuntu/pdf-query-rag-llm-app

cd /home/ubuntu/pdf-query-rag-llm-app

    Step 3
    Create a file requirements.txt for your Python dependencies.

    Copy Code 
    

    vim requirements.txt

    Copy Code 
    

    awscli
pypdf
streamlit
boto3
faiss-cpu
langchain-aws
langchain_community

    Install your Python dependencies.

    Copy Code 
    

    pip install -r requirements.txt

    Step 4
    Create a file pdf_query_rag_llm_app.py which has the PDF query application code.

    Copy Code 
    

    cd /home/ubuntu/pdf-query-rag-llm-app

vim pdf_query_rag_llm_app.py

    Copy Code 
    

    import os
import boto3
import streamlit as st
from langchain_aws import BedrockEmbeddings
from langchain_aws.chat_models import ChatBedrock
from langchain_community.vectorstores.faiss import FAISS
from langchain_community.document_loaders.pdf import PyPDFDirectoryLoader
from langchain.chains.retrieval_qa.base import RetrievalQA
from langchain.prompts import PromptTemplate
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.globals import set_verbose
set_verbose(False)

bedrock = boto3.client(service_name='bedrock-runtime', region_name='us-east-1')
titan_embeddings = BedrockEmbeddings(model_id="amazon.titan-embed-text-v1", client=bedrock)

# Data Preparation
def data_ingestion():
    loader = PyPDFDirectoryLoader("data")
    documents = loader.load()
    text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=500)
    docs = text_splitter.split_documents(documents)
    return docs

# Vector Store Setup
def setup_vector_store(documents):
    vector_store = FAISS.from_documents(
        documents,
        titan_embeddings,
    )
    vector_store.save_local("faiss_index")

# LLM Setup
def load_llm():
    llm = ChatBedrock(model_id="anthropic.claude-3-5-sonnet-20240620-v1:0", client=bedrock, model_kwargs={"max_tokens": 2048})
    return llm

# LLM Guidelines
prompt_template = """Use the following pieces of context to answer the question at the end. Follow these rules:
1. If the answer is not within the context knowledge, state that you do not know, and do not fabricate an answer.
2. If you find the answer, create a detailed, and concise response to the question. Aim for a summary of max 200 words.
3. Do not add extra information not within the context.

{context}

Question: {question}
Helpful Answer:"""

# Prompt Template
prompt = PromptTemplate(template=prompt_template, input_variables=["context", "question"])

# Create QA Chain 
def get_result(llm, vector_store, query):
    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=vector_store.as_retriever(
            search_type="similarity", search_kwargs={"k": 3}
        ),
        chain_type_kwargs={"prompt": prompt},
        return_source_documents=True,
    )
    # Apply LLM
    result = qa_chain.invoke(query)
    return result['result']

# Streamlit Frontend UI Section
def streamlit_ui():
    st.set_page_config("PDF Query RAG LLM Application")
    st.markdown("""
        
    """, unsafe_allow_html=True)
    st.header("PDF Query with Generative AI")

    user_question = st.text_input(r":gray[$\textsf{\normalsize Ask me anything about your PDF collection.}$]")

    left_column, middleleft_column, middleright_column, right_column = st.columns(4, gap="small")
    if left_column.button("Generate Response", key="submit_question") or user_question:
        # first check if the vector store exists
        if not os.path.exists("faiss_index"):
            st.error("Please create the vector store first from the sidebar.")
            return
        if not user_question:
            st.error("Please enter a question.")
            return
        with st.spinner("Generating... this may take a minute..."):
            faiss_index = FAISS.load_local("faiss_index", embeddings=titan_embeddings,
                                           allow_dangerous_deserialization=True)
            llm = load_llm()
            st.write(get_result(llm, faiss_index, user_question))
            st.success("Generated")
    if middleleft_column:
        st.empty()
    if middleright_column:
        st.empty()
    if right_column.button("New Data Update", key="update_vector_store"):
        with st.spinner("Updating... this may take a few minutes as we go through your PDF collection..."):
            docs = data_ingestion()
            setup_vector_store(docs)
            st.success("Updated")

if __name__ == "__main__":
    streamlit_ui()

    Step 5
    Create a data directory to hold your PDF’s. *note you will want to put your PDF’s in this directory that you want to query..

    Copy Code 
    

    cd /home/ubuntu/pdf-query-rag-llm-app

mkdir data

    Step 6
    Create a Systemd service file. Systemd is a service manager and in this use case it will manage streamlit.

    Copy Code 
    

    sudo vim /etc/systemd/system/pdf-query-rag-llm-app.service

    Add the following to pdf-query-rag-llm-app.service

    Copy Code 
    

    [Unit]
Description=PDF query with Generative AI Service
After=network.target
 
[Service]
User=root
Group=root
WorkingDirectory=/home/ubuntu/pdf-query-rag-llm-app
Environment="PATH=/home/ubuntu/pdf-query-rag-llm-app_env/bin"
ExecStart=/home/ubuntu/pdf-query-rag-llm-app_env/bin/streamlit run /home/ubuntu/pdf-query-rag-llm-app/pdf_query_rag_llm_app.py --server.port 8080 --server.headless true
 
[Install]
WantedBy=multi-user.target

    Step 7
    Start your application via Systemd and enable it to auto start after reboot

    Copy Code 
    

    sudo systemctl start pdf-query-rag-llm-app.service

sudo systemctl enable pdf-query-rag-llm-app.service

    Step 8
    Create your applications NGINX config nginx_ai-image-generator.conf that makes NGINX listen on port 80 and proxies requests to Streamlit on port 8080. NGINX will help with connection handling increasing performance.

    Copy Code 
    

    sudo vim /etc/nginx/sites-available/nginx_pdf-query-rag-llm-app.conf

    Add the following to nginx_pdf-query-rag-llm-app.conf

    Copy Code 
    

    server {
    listen 80 default_server;

    location / {
        include proxy_params;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP      $remote_addr;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_buffers 8 24k;
        proxy_buffer_size 4k;
        proxy_pass http://127.0.0.1:8080;
    }
    location /_stcore/stream {
        proxy_pass http://127.0.0.1:8080/_stcore/stream;
        proxy_http_version 1.1;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400;
    }
}

    Step 9
    Delete your default NGINX conf file, enable your new NGINX conf and restart NGINX (Port 80)

    Copy Code 
    

    
sudo rm /etc/nginx/sites-enabled/default

sudo ln -s /etc/nginx/sites-available/nginx_pdf-query-rag-llm-app.conf /etc/nginx/sites-enabled

sudo systemctl restart nginx

    Step 10
    Test your application, remember to put your PDF’s that you want to query in the data directory on the instance and click New Data Update before querying.

    Copy Code 
    

    http://{yourhost}

    Notes:

    • Make sure to open up port 80 in your EC2 Security Group associated to the instance.
    • For HTTPS (TLS) you can use AWS ALB or AWS CloudFront.
    • Depending on how many PDF’s you have, how big the PDF’s are, and your CPU specifications using the New Data Update button can take awhile as it builds your vector embeddings.
    • Any time you add PDF’s or change them make sure to click “New Data Update” to update/build your vector embeddings.
    • This application does not take into consideration security controls, that is your responsibility.
    • Please read Amazon Bedrock FAQ’s for general questions about AWS LLM resources used.

    Summary:
    Hopefully this blog article helps you create a generative AI PDF query web application which is scoped to your specific data and context leveraging a RAG architecture. Retrieval-augmented generation (RAG) is a powerful architecture choice to both leverage a trained model in this case Claude 3.5 Sonnet, and your organizations specific data (vectorized) without re-training the LLM model, but rather augmenting its knowledge base.

    If you like this blog article you may want to read my other article on Building an Asynchronous GenAI Image Generator API.

    The post Building a GenAI PDF Query App with a RAG Architecture first appeared on Phil Chen.

    ]]>         Scaling a Python Flask App with NGINX using Multiple Containers with Docker Compose https://philchen.com/2019/07/15/scaling-a-python-flask-app-with-nginx-using-multiple-containers-with-docker-compose/ Mon, 15 Jul 2019 19:41:36 +0000 https://philchen.com/?p=2107 This article will go over scaling a Python Flask application utilizing a multi-container docker architecture. Leveraging Docker Compose we will create a NGINX Docker container that will act as a load balancer with two Python Flask application containers it will direct traffic to. The Python Flask application will serve a web page via a GET […]

    The post Scaling a Python Flask App with NGINX using Multiple Containers with Docker Compose first appeared on Phil Chen.

    ]]>     This article will go over scaling a Python Flask application utilizing a multi-container docker architecture. Leveraging Docker Compose we will create a NGINX Docker container that will act as a load balancer with two Python Flask application containers it will direct traffic to. The Python Flask application will serve a web page via a GET request and will be running Gunicorn.

    Assumptions:

    • You have Docker installed
    • These instructions are were done on a Mac
    • You are leveraging multiple containers on one host (docker engine), if not read the bottom of this post about “docker stack deploy”.

    Quick Links:

    GitHub repo with files referenced in this blog ubuntu-flask-gunicorn-nginx-docker-compose

    Docker Hub repo with some of the images used in the blog here.

    File Structure:

    Copy Code 

    
ubuntu-flask-gunicorn-nginx-docker-compose/
    
    |
    
    docker-compose.yml
    
    |
    
    app/
    
    |   –> Dockerfile
    
    |   –> src
    
    |          –> app01.py
    
    |          –> gunicorn_config.py
    
    |          –> wsgi.py
    
    |          –> requirements.txt
    
    |
    
    nginx/
    
          –> Dockerfile
    
          –> nginx.conf

    Step 0
    Create a directory for your project.
    Copy Code 
    

    mkdir ubuntu-flask-gunicorn-nginx-docker-compose

cd ubuntu-flask-gunicorn-nginx-docker-compose

mkdir -p app/src

mkdir nginx

    Step 1
    Create a file requirements.txt for your Python dependencies, such as Flask or Gunicorn. For more information about PIP requirements.txt read here.

    Copy Code 
    

    cd app/src
    Copy Code 
    

    vim requirements.txt

    Add the following to the requirements.txt

    Copy Code 
    

    Click==7.0
Flask==1.0.3
gunicorn==19.9.0
itsdangerous==1.1.0
Jinja2==2.10.1
MarkupSafe==1.1.1
Werkzeug==0.15.4

    Step 2
    Create a file app01.py which will be a simple Flask web app. Flask is a microframework for Python based on Werkzeug and Jinja2. For more information about Flask read here.

    Copy Code 
    

    vim app01.py

    Add the following to app01.py

    Copy Code 
    

    from flask import Flask
hello = Flask(__name__)

@hello.route("/")
def greeting():
    return "
    Hello World!
    "

if __name__ == "__main__":
    hello.run(host='0.0.0.0')

    Step 3
    Create a file wsgi.py which will be the gateway from the webserver to your app. For more information about WSGI read here.

    Copy Code 
    

    vim wsgi.py

    Add the following to wsgi.py

    Copy Code 
    

    from app01 import hello

if __name__ == "__main__":
    hello.run()

    Step 4
    Create a file gunicorn_config.py which will be the configurations Gunicorn will utilize. Gunicorn is a Python WSGI HTTP Server for UNIX. For more information about Gunicorn read here.

    Copy Code 
    

    vim gunicorn_config.py

    Add the following to gunicorn_config.py
    *Note we set workers to 2 because if you only have one worker, and it’s handling a slow query, the heartbeat query will timeout which could remove it from a load balancer. Also container schedulers expect logs to come out on stdout and stderr so we have it set in the config as such. We also leverage /dev/shm vs default /tmp to avoid timeouts accessing ram vs disk.

    Copy Code 
    

    pidfile = 'app01.pid'
worker_tmp_dir = '/dev/shm'
worker_class = 'gthread'
workers = 2
worker_connections = 1000
timeout = 30
keepalive = 2
threads = 4
proc_name = 'app01'
bind = '0.0.0.0:8080'
backlog = 2048
accesslog = '-'
errorlog = '-'
user = 'ubuntu'
group = 'ubuntu'

    Step 5
    Create a Dockerfile which contains the commands to build your Python Flask App Docker image. For more information on Dockerfile read here.

    Copy Code 
    

    cd ../

vim Dockerfile

    Add the following to Dockerfile
    *Note we pull a base ubuntu 18.04 image with python 3.7.3 from my Docker Hub repo you could point this to the official Ubuntu repo and add a Python image or install line. All the files are copied into the /home/ubuntu container directory and referenced from there.

    Copy Code 
    

    FROM nethacker/ubuntu-18-04-python-3:python-3.7.3
COPY src/requirements.txt /root/
RUN pip install -r /root/requirements.txt && useradd -m ubuntu
ENV HOME=/home/ubuntu
USER ubuntu
COPY src/app01.py src/wsgi.py src/gunicorn_config.py /home/ubuntu/
WORKDIR /home/ubuntu/
EXPOSE 8080
CMD ["gunicorn", "-c", "gunicorn_config.py", "wsgi:hello"]

    Step 6
    Create a NGINX configuration file to make a reverse proxy load balancer to your Python Flask application

    Copy Code 
    

    cd ../nginx/

vim nginx.conf

    Add the following to your nginx.conf file for NGINX to act as a reverse proxy load balancer.

    Copy Code 
    

    events { worker_connections 1024; }

http {

 proxy_headers_hash_max_size 1024;
 proxy_headers_hash_bucket_size 64;

 upstream localhost {
    # References to our app containers, via docker compose
    server app01:8080;
    server app02:8080;
 }
 server {
    listen 80;
    server_name localhost;
    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP      $remote_addr;
        proxy_redirect off;
        proxy_buffers 8 24k;
        proxy_buffer_size 4k;
        proxy_pass http://localhost;
        proxy_set_header Host $host;
    }
  }
}

    Step 7
    Create a file Dockerfile which contains the commands to build your NGINX Docker image.

    Copy Code 
    

    vim Dockerfile

    Add the following to Dockerfile

    Copy Code 
    

    FROM nethacker/ubuntu-18-04-nginx:1.17.1
RUN apt-get update && apt-get install -y \
    build-essential \
    curl \
  && rm -rf /var/lib/apt/lists/*
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

    Step 8
    Create your Docker Compose YAML file outlining one NGINX container with two backend Python Flask application containers to which to direct traffic too. Also specify the NGINX port as well increasing shm size for Gunicorn to use.

    Copy Code 
    

    cd ../

vim docker-compose.yml

    Add the following to docker-compose.yml file.

    Copy Code 
    

    version: '3.7'
services:
    app01:
        shm_size: '1000000000'
        build:
            context: ./app
        tty: true
        volumes:
            - './app/src:/home/ubuntu'
    app02:
        shm_size: '1000000000'
        build:
            context: ./app
        tty: true
        volumes:
            - './app/src:/home/ubuntu'
    nginx:
        build: ./nginx
        tty: true
        links:
            - app01
            - app02
        ports:
            - '80:80'

    Step 9
    Build and Start your Docker images using Docker Compose, you will end up with one NGINX container with two backend Python Flask application containers. The NGINX container will listen on port 80 and forward traffic to the backend apps on 8080.

    Copy Code 
    

    docker-compose up --build --detach

    Step 10
    Test your Docker container

    If you didn’t modify the example you should be able to go to localhost port 80 in a browser and get a red “Hello World” message.

    Copy Code 
    

    http://localhost

    You can also do the following to access your containers with a bash shell to poke around.

    Find the running Docker container id you wish to examine.

    Copy Code 
    

    docker ps

    Get and interactive shell on the container.

    Copy Code 
    

    docker exec -it {id here} /bin/bash

    Hopefully this basic overview of Docker Compose and multi-containers on a single host/docker engine helps you scale your application.

    On a side note,

    Copy Code 
    

    docker-compose

    command appears to be transitioning to:

    Copy Code 
    

    docker stack deploy

    with the difference “docker-compose” can do builds in the docker-compose.yml and 2.0/3.0 spec with caveats, but “docker stack deploy” cannot do build commands in the docker-compose.yml and needs prebuilt images as well as 3.0 spec making docker compose nicer for development purposes but “docker stack deploy” a more production oriented method with multiple containers over multiple hosts leveraging swarm. In both cases docker-compose.yml is used and Docker will ignore commands not support by the respective compose vs stack call (silently). I will do a post on Docker Swarm next.

    The post Scaling a Python Flask App with NGINX using Multiple Containers with Docker Compose first appeared on Phil Chen.

    ]]>         A scalable Flask application using Gunicorn on Ubuntu 18.04 in Docker https://philchen.com/2019/07/09/a-scalable-flask-application-using-gunicorn-on-ubuntu-18-04-in-docker/ Tue, 09 Jul 2019 22:05:39 +0000 https://philchen.com/?p=2080 This article will cover creating a scalable Flask application using Gunicorn on Ubuntu 18.04 in Docker. We loosely are defining Flask application to mean serving up a web page via a GET request, however this blog can be used as an example to build a website, Restful API, or any number of things leveraging Docker. […]

    The post A scalable Flask application using Gunicorn on Ubuntu 18.04 in Docker first appeared on Phil Chen.

    ]]>     This article will cover creating a scalable Flask application using Gunicorn on Ubuntu 18.04 in Docker. We loosely are defining Flask application to mean serving up a web page via a GET request, however this blog can be used as an example to build a website, Restful API, or any number of things leveraging Docker. Via a Dockerfile we will build a Docker image that you can modify for your own Flask application needs, the example in this blog will be a simple “hello world” web page.

    Quick Links:

    GitHub repo with files referenced in this blog ubuntu-flask-gunicorn-docker

    Docker Hub repo for the example app referenced in this blog nethacker/ubuntu-18-04-flask-gunicorn-example

    Docker Hub repo for Ubuntu with Flask and Gunicorn with no app nethacker/ubuntu-18-04-flask-gunicorn

    Assumptions:

  • You have Docker installed
  • These instructions are were done on a Mac

    • Step 0
    Create a directory for your project.

    Copy Code 
    

    mkdir ubuntu-flask-gunicorn-docker

cd ubuntu-flask-gunicorn-docker

    Step 1
    Create a file requirements.txt for your Python dependencies, such as Flask or Gunicorn. For more information about PIP requirements.txt read here.

    Copy Code 
    

    vim requirements.txt

    Add the following to the requirements.txt

    Copy Code 
    

    Click==7.0
Flask==1.0.3
gunicorn==19.9.0
itsdangerous==1.1.0
Jinja2==2.10.1
MarkupSafe==1.1.1
Werkzeug==0.15.4

    Step 2
    Create a file app01.py which will be a simple Flask web app. Flask is a microframework for Python based on Werkzeug and Jinja2. For more information about Flask read here.

    Copy Code 
    

    vim app01.py

    Add the following to app01.py

    Copy Code 
    

    from flask import Flask
hello = Flask(__name__)

@hello.route("/")
def greeting():
    return "
    Hello World!
    "

if __name__ == "__main__":
    hello.run(host='0.0.0.0')

    Step 3
    Create a file wsgi.py which will be the gateway from the webserver to your app. For more information about WSGI read here.

    Copy Code 
    

    vim wsgi.py

    Add the following to wsgi.py

    Copy Code 
    

    from app01 import hello

if __name__ == "__main__":
    hello.run()

    Step 4
    Create a file gunicorn_config.py which will be the configurations Gunicorn will utilize. Gunicorn is a Python WSGI HTTP Server for UNIX. For more information about Gunicorn read here.

    Copy Code 
    

    vim gunicorn_config.py

    Add the following to gunicorn_config.py
    *Note we set workers to 2 because if you only have one worker, and it’s handling a slow query, the heartbeat query will timeout which could remove it from a load balancer. Also container schedulers expect logs to come out on stdout and stderr so we have it set in the config as such. We also leverage /dev/shm vs default /tmp to avoid timeouts accessing ram vs disk.

    Copy Code 
    

    pidfile = 'app01.pid'
worker_tmp_dir = '/dev/shm'
worker_class = 'gthread'
workers = 2
worker_connections = 1000
timeout = 30
keepalive = 2
threads = 4
proc_name = 'app01'
bind = '0.0.0.0:8080'
backlog = 2048
accesslog = '-'
errorlog = '-'
user = 'ubuntu'
group = 'ubuntu'

    Step 5
    Create a file Dockerfile which contains the commands to build your Docker image. For more information on Dockerfile read here.

    Copy Code 
    

    vim Dockerfile

    Add the following to Dockerfile
    *Note we pull a base ubuntu 18.04 image with python 3.7.3 from my Docker Hub repo you could point this to the official Ubuntu repo and add a Python image or install line. All the files are copied into the /home/ubuntu container directory and referenced from there.

    Copy Code 
    

    FROM nethacker/ubuntu-18-04-python-3:python-3.7.3
COPY requirements.txt /root/
RUN pip install -r /root/requirements.txt && useradd -m ubuntu
ENV HOME=/home/ubuntu
USER ubuntu
COPY app01.py wsgi.py gunicorn_config.py /home/ubuntu/
WORKDIR /home/ubuntu/
EXPOSE 8080
CMD ["gunicorn", "-c", "gunicorn_config.py", "wsgi:hello"]

    Step 6
    Build your Docker image
    *Note you can -t tag this with your own naming convention

    Copy Code 
    

    docker build -t example/ubuntu-flask-gunicorn-docker:latest .

    Step 7
    Start your Docker container from the Docker image you built. Docker container environments are different then VM’s because of this we set –shm-size to a bigger shared memory size. Gunicorn has a config entry to use shared memory (/dev/shm) vs disk (/tmp) for Gunicorn health checks to avoid timeouts accessing ram vs disk. The setting 80:8080 sets the Docker container to map localhost 80 to container port 8080.

    Copy Code 
    

    docker run --shm-size=256m --detach -p 80:8080 example/ubuntu-flask-gunicorn-docker:latest

    Step 8
    Test your Docker container

    If you didn’t modify the Dockerfile you should be able to go to localhost port 80 in a browser and get a red “Hello World” message.

    Copy Code 
    

    http://localhost

    You can also do the following to access the container with a bash shell to poke around.

    Find the running Docker container id.

    Copy Code 
    

    docker ps

    Get and interactive shell on the container.

    Copy Code 
    

    docker exec -it {id here} /bin/bash

    Hopefully this basic overview helps you build your own containers!

    The post A scalable Flask application using Gunicorn on Ubuntu 18.04 in Docker first appeared on Phil Chen.

    ]]>         How to make a Python Web App in Virtualenv using Flask, Gunicorn, NGINX on Ubuntu 18.04 https://philchen.com/2019/02/11/how-to-make-a-python-web-app-in-virtualenv-using-flask-gunicorn-nginx-on-ubuntu-18-04/ Tue, 12 Feb 2019 03:50:56 +0000 https://philchen.com/?p=2002 This article will cover creating a scalable Python Flask web application on Ubuntu 18.04 using Gunicorn and NGINX. The web application also leverages Virtualenv to provide an isolated Python environment and Systemd as a service manager. We loosely are defining web application to mean serving up a web page via a GET request, however this […]

    The post How to make a Python Web App in Virtualenv using Flask, Gunicorn, NGINX on Ubuntu 18.04 first appeared on Phil Chen.

    ]]>     This article will cover creating a scalable Python Flask web application on Ubuntu 18.04 using Gunicorn and NGINX. The web application also leverages Virtualenv to provide an isolated Python environment and Systemd as a service manager. We loosely are defining web application to mean serving up a web page via a GET request, however this blog can be used as an example to build a website, Restful API, or any number of things.

    *This is an updated approach to an older blog post of mine How to make a Scalable Python Web App using Flask, Gunicorn, NGINX on Ubuntu 14.04 from 2015.

    I have created a GitHub repo scalable-ubuntu-flask-gunicorn-nginx available for you to get started quickly with a setup.sh file that does all the steps below via one bash script.

    If you would like to do this step by step please continue reading below:

    Assumptions:

  • You have a Ubuntu 18.04 Server or Cloud Instance
  • You are using ubuntu as your user and have sudo privileges

    • Step 0
    Update your Ubuntu packages

    Copy Code 
    

    sudo apt update

    Step 1
    Time Matters! Sync’ing time is important all servers drift which can effect applications negatively.

    Copy Code 
    

    sudo apt -y install ntpdate

sudo ntpdate pool.ntp.org

sudo apt -y install ntp

    Step 2
    Install Python Dependencies and Virtualenv, you will be installing Python 3 and leveraging Virtualenv to have an isolated environment for your Python dependencies specific to your application.

    Copy Code 
    

    sudo apt -y install build-essential openssl

sudo apt -y install libpq-dev libssl-dev libffi-dev zlib1g-dev

sudo apt -y install python3-pip python3-dev

sudo pip3 install virtualenvwrapper

    Step 3
    Install NGINX, it will act as a reverse proxy for scaling purposes.

    Copy Code 
    

    sudo apt -y install nginx

    Step 4
    Configure your .bashrc file so that your ubuntu user can use Virtualenv

    Copy Code 
    

    vim ~/.bashrc

    Add the following to the bottom of your .bashrc file

    Copy Code 
    

    # default location of virtual environment directories
export WORKON_HOME=$HOME/.virtualenvs
# default python version to use with virtualenv
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
source `which virtualenvwrapper.sh`

    Step 5
    Source your .bashrc file to activate your changes

    Copy Code 
    

    source ~/.bashrc

    Step 6
    Create a directory to keep applications in

    Copy Code 
    

    mkdir /home/ubuntu/flask_apps

cd /home/ubuntu/flask_apps

    Step 7
    Create your Virtualenv project environment named app01_env

    Copy Code 
    

    virtualenv app01_env

    Step 8
    Activate your Virtualenv and install Python packages for your application specific to the new project environment. The three packages listed are gunicorn (webserver), flask (Python microframework), and setproctitle (to view your processes friendly name when using ps). After use deactivate to remove yourself from this environment.

    Copy Code 
    

    source app01_env/bin/activate

pip install gunicorn

pip install flask

pip install setproctitle

deactivate

    Step 9
    Create your Python Flask application that says Hello World

    Copy Code 
    

    vim /home/ubuntu/flask_apps/app01_env/app01.py

    app01.py

    Copy Code 
    

    from flask import Flask
hello = Flask(__name__)

@hello.route("/")
def greeting():
    return "
    Hello World!
    "

if __name__ == "__main__":
    hello.run(host='0.0.0.0')

    Step 10
    Create your webserver gateway interface for the Flask microframework

    Copy Code 
    

    vim /home/ubuntu/flask_apps/app01_env/wsgi.py

    wsgi.py

    Copy Code 
    

    from app01 import hello

if __name__ == "__main__":
    hello.run()

    Step 11
    Create your Gunicorn config file which holds your Gunicorn settings. Gunicorn is essentially your webserver for your application. The below settings are optimized for a dual core server.

    Copy Code 
    

    vim /home/ubuntu/flask_apps/app01_env/gunicorn_config.py

    gunicorn.py

    Copy Code 
    

    pidfile = 'app01.pid'
worker_class = 'gthread'
workers = 5
worker_connections = 1000
timeout = 30
keepalive = 2
threads = 2
proc_name = 'app01'
bind = '0.0.0.0:8080'
backlog = 2048
accesslog = 'access.log'
errorlog = 'error.log'
user = 'ubuntu'
group = 'ubuntu'

    Step 12
    Create a Systemd service file. Systemd is a service manager and in this use case it will manage Gunicorn.

    Copy Code 
    

    sudo vim /etc/systemd/system/app01.service

    app01.service

    Copy Code 
    

    [Unit]
Description=Gunicorn for Flask app01
After=network.target

[Service]
User=ubuntu
Group=ubuntu
WorkingDirectory=/home/ubuntu/flask_apps/app01_env
Environment="PATH=/home/ubuntu/flask_apps/app01_env/bin"
ExecStart=/home/ubuntu/flask_apps/app01_env/bin/gunicorn --config=gunicorn_config.py wsgi:hello

[Install]
WantedBy=multi-user.target

    Step 13
    Start your application via Systemd and enable it to auto start after reboot

    Copy Code 
    

    sudo systemctl start app01

sudo systemctl enable app01.service

    Step 14
    Create your applications NGINX config that makes NGINX listen on port 80 and proxies requests to Gunicorn on port 8080. NGINX will help with connection handling increasing performance.

    Copy Code 
    

    sudo vim /etc/nginx/sites-available/nginx_app01.conf

    nginx_app01.conf

    Copy Code 
    

    server {
    listen 80 default_server;

    location / {
        include proxy_params;
      	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Real-IP	$remote_addr;
      	proxy_set_header Host $http_host;
      	proxy_redirect off;
        proxy_buffers 8 24k;
        proxy_buffer_size 4k;
        proxy_pass http://127.0.0.1:8080;
    }
}

    Step 15
    Delete your default NGINX conf file, enable your new NGINX conf and restart NGINX

    Copy Code 
    

    sudo rm /etc/nginx/sites-enabled/default

sudo ln -s /etc/nginx/sites-available/nginx_app01.conf /etc/nginx/sites-enabled

sudo systemctl restart nginx

    Step 16
    If the server or instance you installed this on has port 80 available for you to reach. Enter the server IP or hostname into your browser and you should see “Hello World!” in red, which tells you your Python Flask application is working.

    Performance Settings

  • Gunicorn is configured with 5 workers leveraging threading (2 per worker) each worker can handle 1000 connections. Typical formula is 2 workers per cpu core + 1 worker
  • Gunicorn Timeout value is set to 30 seconds and keepalive is set to 2 seconds
  • NGINX is set to use 8 buffers and 24K size per buffer when reading a response from the proxied server for a single connection
  • NGINX is set to 4k buffer size used for headers from the pool
  • NGINX worker_processes are set to “auto” for detecting number of cores and setting that value

    • The post How to make a Python Web App in Virtualenv using Flask, Gunicorn, NGINX on Ubuntu 18.04 first appeared on Phil Chen.

    ]]>         Working with IP address information using Ruby https://philchen.com/2016/06/02/working-with-ip-address-information-using-ruby/ Thu, 02 Jun 2016 19:16:08 +0000 http://3.84.23.23/?p=1924 I recently needed to create an IP address range in array format, and came across a nice Ruby Class “ipaddr” for working with IP address information. My goal was to white list an IP by cross referencing it with the IP address range. Here is a standalone example of converting the IP Range into an […]

    The post Working with IP address information using Ruby first appeared on Phil Chen.

    ]]>     I recently needed to create an IP address range in array format, and came across a nice Ruby Class “ipaddr” for working with IP address information. My goal was to white list an IP by cross referencing it with the IP address range.

    Here is a standalone example of converting the IP Range into an array.

    Copy Code 
    

    #!/usr/bin/env ruby

require 'ipaddr'

def ip_range(first, last)
  first = IPAddr.new(first)
  last  = IPAddr.new(last)
  (first..last).map(&:to_s)
end

range_calc = ip_range("172.30.20.0", "172.30.20.255")

puts range_calc.to_a

    Here is an example in Sinatra of using this method to check against
    Copy Code 
    

    require 'ipaddr'

get '/blah/blah/blah' do

def ip_range(first, last)
  first = IPAddr.new(first)
  last  = IPAddr.new(last)
  (first..last).map(&:to_s)
end

range_calc = ip_range("172.30.20.0", "172.30.20.255")

$WHITE_LIST_HOSTS = ["127.0.0.1","173.255.251.204","54.223.213.220"] + range_calc.to_a

request_ip = @env['HTTP_X_REAL_IP']
  if
    !$WHITE_LIST_HOSTS.include? request_ip

  return "Not Authorized"

  else
    Do work here...
  end
end

    Here is another standalone example variation using a method of ip-addr, if the requesting ip is in the range it will return true.
    Copy Code 
    

    #!/usr/bin/env ruby

require 'ipaddr'

first = IPAddr.new("172.30.20.0/24")

requesting_ip = IPAddr.new("172.30.20.200")

puts first.include?(requesting_ip)

    Hope this is helpful. The Class ‘ipaddr‘ has other useful methods you should check out.

    The post Working with IP address information using Ruby first appeared on Phil Chen.

    ]]>         How to Create a Private Docker Registry Using AWS and Docker https://philchen.com/2015/11/16/how-to-create-a-private-docker-registry-using-aws-and-docker/ Mon, 16 Nov 2015 19:00:49 +0000 http://3.84.23.23/?p=1888 This article will cover creating a Docker Registry leveraging Amazon Web Services (AWS) and a Docker registry container itself. This registry will be built on AWS EC2 instance running Ubuntu 14.04 and leveraging an EBS Volume so that you can take backup snapshots of your registry. This setup will be secured by leveraging VPC and […]

    The post How to Create a Private Docker Registry Using AWS and Docker first appeared on Phil Chen.

    ]]>     This article will cover creating a Docker Registry leveraging Amazon Web Services (AWS) and a Docker registry container itself. This registry will be built on AWS EC2 instance running Ubuntu 14.04 and leveraging an EBS Volume so that you can take backup snapshots of your registry. This setup will be secured by leveraging VPC and AWS Security Groups. (You should probably put authentication in even if its in your private network but I wont cover that.)

    Step 0
    Create your AWS Environment

    Create a AWS Security Group for your Docker Registry Instance allowing port 80. Launch an AWS EC2 Instance running Ubuntu 14.04 in the designated region and VPC of your choice through the AWS Console applying the Security Group you created. Create and size an AWS EBS Volume to your needs and attach it to the instance you started via the AWS Console.

    Step 1
    Time Matters!

    Copy Code 
    

    ubuntu$ sudo apt-get update

ubuntu$ sudo ntpdate pool.ntp.org
 
ubuntu$ sudo apt-get install ntp

    Step 2
    Install Build Tools *just because

    Copy Code 
    

    ubuntu$ sudo apt-get install build-essential

    Step 3
    Create a file system for the EBS Volume you created and mount it.

    Copy Code 
    

    ubuntu$ sudo cat /proc/partitions

major minor  #blocks  name

   7        0  104857600 loop0
   7        1    2097152 loop1
 202        0  104857600 xvda
 202        1  104848222 xvda1
 252        0  104857600 dm-0
 202       80  104857600 xvdf
 252        1   10485760 dm-1

ubuntu$ sudo mkfs -t ext4 /dev/xvdf

ubuntu$ sudo mkdir /data

ubuntu$ sudo mount /dev/xvdf /data

ubuntu$ sudo vim /etc/fstab

*ADD BELOW
/dev/xvdf    /data   ext4    defaults    1 1

    Step 4
    Install Docker

    Copy Code 
    

    ubuntu$ sudo apt-get update

ubuntu$ sudo apt-get -y install docker.io

ubuntu$ sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker

    Step 5
    Install Docker Registry Container

    Copy Code 
    

    ubuntu$ sudo docker run -d -p 80:5000 --restart=always -v /data:/var/lib/registry registry:2

    Step 6
    Create a Security Group for your AWS ELB opening port 443 via the AWS Console

    Step 7
    Create an Internal AWS ELB that has a Load Balancer Port 443 and Server Port 80 and apply the Security Group you created in the previous step, then put your AWS EC2 instance in it. Create friendly DNS CNAME to that load balancer. This is needed since Docker Registry needs to leverage SSL.

    Step 8
    From a SEPARATE Development Docker Server Test Your New Registry

    Copy Code 
    

    ubuntu$ sudo docker pull ubuntu

ubuntu$ sudo docker tag ubuntu the-dns-name-to-elb/mytestimage:1

ubuntu$ sudo docker push the-dns-name-to-your-elb/mytestimage

ubuntu$ sudo docker pull the-dns-name-to-your-elb/mytestimage

    *NOTES