구글 코랩에서 오픈웹UI와 OpenAI API 연동하기

Editors Pick Agentic AI Artificial Intelligence AI Infrastructure Applications Technology Generative AI Language Model Staff Tutorials In this tutorial, we build a complete Open WebUI setup in Colab, in a practical, hands-on way, using Python. We begin by installing the required dependencies, then securely provide our OpenAI API key through terminal-based secret input so that sensitive credentials are not exposed directly in the notebook. From there, we configure the environment variables needed for Open WebUI to communicate with the OpenAI API, define a default model, prepare a data directory for runtime storage, and launch the Open WebUI server inside the Colab environment. To make the interface accessible outside the notebook, we also create a public tunnel and capture a shareable URL that lets us open and use the application directly in the browser. Through this process, we get Open WebUI running end-to-end and understand how the key pieces of deployment, configuration, access, and runtime management fit together in a Colab-based workflow. Copy Code Copied Use a different Browser import os import re import time import json import shutil import signal import secrets import subprocess import urllib.request from getpass import getpass from pathlib import Path print("Installing Open WebUI and helper packages...") subprocess.check_call([ "python", "-m", "pip", "install", "-q", "open-webui", "requests", "nest_asyncio" ]) print("\nEnter your OpenAI API key securely.") openai_api_key = getpass("OpenAI API Key: ").strip() if not openai_api_key: raise ValueError("OpenAI API key cannot be empty.") default_model = input("Default model to use inside Open WebUI [gpt-4o-mini]: ").strip() if not default_model: default_model = "gpt-4o-mini" We begin by importing all the required Python modules for managing system operations, securing input, handling file paths, running subprocesses, and accessing the network. We then install Open WebUI and the supporting packages needed to run the application smoothly inside Google Colab. After that, we securely enter our OpenAI API key through terminal input and define the default model that we want Open WebUI to use. Copy Code Copied Use a different Browser os.environ["ENABLE_OPENAI_API"] = "True" os.environ["OPENAI_API_KEY"] = openai_api_key os.environ["OPENAI_API_BASE_URL"] = "https://api.openai.com/v1" os.environ["WEBUI_SECRET_KEY"] = secrets.token_hex(32) os.environ["WEBUI_NAME"] = "Open WebUI on Colab" os.environ["DEFAULT_MODELS"] = default_model data_dir = Path("/content/open-webui-data") data_dir.mkdir(parents=True, exist_ok=True) os.environ["DATA_DIR"] = str(data_dir) We configure the environment variables that allow Open WebUI to connect properly with the OpenAI API. We store the API key, define the OpenAI base endpoint, generate a secret key for the web interface, and assign a default model and interface name for the session. We also create a dedicated data directory in the Colab environment so that Open WebUI has a structured location to store its runtime data. Copy Code Copied Use a different Browser cloudflared_path = Path("/content/cloudflared") if not cloudflared_path.exists(): print("\nDownloading cloudflared...") url = "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64" urllib.request.urlretrieve(url, cloudflared_path) cloudflared_path.chmod(0o755) print("\nStarting Open WebUI server...") server_log = open("/content/open-webui-server.log", "w") server_proc = subprocess.Popen( ["open-webui", "serve"], stdout=server_log, stderr=subprocess.STDOUT, env=os.environ.copy() ) We prepare the tunnel component by downloading the CloudFlare binary if it is not already available in the Colab environment. Once that is ready, we start the Open WebUI server and direct its output into a log file so that we can inspect its behavior if needed. This part of the tutorial sets up the core application process that powers the browser-based interface. Copy Code Copied Use a different Browser local_url = "http://127.0.0.1:8080" ready = False for _ in range(120): try: import requests r = requests.get(local_url, timeout=2) if r.status_code < 500: ready = True break except Exception: pass time.sleep(2) if not ready: server_log.close() with open("/content/open-webui-server.log", "r") as f: logs = f.read()[-4000:] raise RuntimeError( "Open WebUI did not start successfully.\n\n" "Recent logs:\n" f"{logs}" ) print("Open WebUI is running locally at:", local_url) print("\nCreating public tunnel...") tunnel_proc = subprocess.Popen( [str(cloudflared_path), "tunnel", "--url", local_url, "--no-autoupdate"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True ) We repeatedly check whether the Open WebUI server has started successfully on the local Colab port. If the server does not start properly, we read the recent logs and raise a clear error so that we can understand what went wrong. Once the server is confirmed to be running, we create a public tunnel to make the local interface accessible from outside Colab. Copy Code Copied Use a different Browser public_url = None start_time = time.time() while time.time() - start_time < 90: line = tunnel_proc.stdout.readline() if not line: time.sleep(1) continue match = re.search(r"https://[-a-zA-Z0-9]+\.trycloudflare\.com", line) if match: public_url = match.group(0) break if not public_url: with open("/content/open-webui-server.log", "r") as f: server_logs = f.read()[-3000:] raise RuntimeError( "Tunnel started but no public URL was captured.\n\n" "Open WebUI server logs:\n" f"{server_logs}" ) print("\n" + "=" * 80) print("Open WebUI is ready.") print("Public URL:", public_url) print("Local URL :", local_url) print("=" * 80) print("\nWhat to do next:") print("1. Open the Public URL.") print("2. Create your admin account the first time you open it.") print("3. Go to the model selector and choose:", default_model) print("4. Start chatting with OpenAI through Open WebUI.") print("\nUseful notes:") print("- Your OpenAI API key was passed through environment variables.") print("- Data persists only for the current Colab runtime unless you mount Drive.") print("- If the tunnel stops, rerun the cell.") def tail_open_webui_logs(lines=80): log_path = "/content/open-webui-server.log" if not os.path.exists(log_path): print("No server log found.") return with open(log_path, "r") as f: content = f.readlines() print("".join(content[-lines:])) def stop_open_webui(): global server_proc, tunnel_proc, server_log for proc in [tunnel_proc, server_proc]: try: if proc and proc.poll() is None: proc.terminate() except Exception: pass try: server_log.close() except Exception: pass print("Stopped Open WebUI and tunnel.") print("\nHelpers available:") print("- tail_open_webui_logs()") print("- stop_open_webui()") We capture the public tunnel URL and print the final access details so that we can open Open WebUI directly in the browser. We also display the next steps for using the interface, including creating an admin account and selecting the configured model. Also, we define helper functions for checking logs and stopping the running processes, which makes the overall setup easier for us to manage and reuse. In conclusion, we created a fully functional Open WebUI deployment on Colab and connected it to OpenAI in a secure, structured manner. We installed the application and its supporting packages, provided authentication details via protected input, configured the backend connection to the OpenAI API, and started the local web server powering the interface. We then exposed that server through a public tunnel, making the application usable through a browser without requiring local installation on our machine. In addition, we included helper functions for viewing logs and stopping the running services, which makes the setup easier to manage and troubleshoot during experimentation. Overall, we established a reusable, practical workflow that helps us quickly spin up Open WebUI in Colab,