How to Build a Personal AI Development Cloud Environment in One Hour

Stop Tinkering with Local Environments: Build Your AI Development Cloud Workbench in One Hour

Last year, I was maintaining three projects simultaneously. My local machine was running MySQL, PostgreSQL, Redis, and a fleet of Docker containers. My laptop fan never stopped roaring. The breaking point came when a macOS upgrade completely wiped out an environment I had spent half a day configuring. Rebuilding it took another entire afternoon.

If you've ever faced scenarios like:

• Switching projects means switching database versions and local environments
• Onboarding a new team member turns into a nightmare of environment configuration
• Wanting to run an AI LLM demo, but spending a week debugging GPU setups
• Needing a quick sandbox to test an idea without cluttering your local machine

This tutorial is here to solve those problems. I'll walk you through building a complete cloud development environment on Sealos from scratch: a cloud DevBox for coding, on-demand database provisioning, and one-click AI app deployment. Follow along, and in about an hour, you'll have a fully functional, long-lasting cloud workspace accessible from any browser.

1. What is Sealos, and Why Choose It?

Sealos is an AI-native cloud operating system built on top of Kubernetes. In plain English: it abstracts all the complexity of K8s into simple, click-and-go operations while preserving the full power of Kubernetes under the hood.

Its core value propositions include:

• Zero Local Installs: Code and run services directly in your browser. Zero dependencies on your local machine.
• Databases Out-of-the-Box: MySQL, PostgreSQL, Redis, MongoDB can be provisioned with one click. No need to docker run manually.
• AI-Native Support: The App Store features popular AI tools like FastGPT. Launch them with a single click.
• Native K8s Underpinning: This means your skills won't become obsolete, and everything you learn translates directly to any cloud environment.

With 18k+ GitHub stars and an active community, Sealos is ideal for personal workbenches, team development environments, or rapidly prototyping AI applications.

2. Prerequisites

Before we begin, you only need:

1. A Web Browser (Chrome, Edge, or Safari)
2. An Email Address (for Sealos account registration)
3. Basic Docker/K8s Awareness (You don't need to write YAML, but knowing what Pods and Deployments are helps)
4. Internet Access (Sealos's public cloud instances default to overseas nodes. For domestic users in China, the mirror site is os.sealos.io)

If you've never touched K8s, don't worry. This tutorial bypasses all low-level details and focuses strictly on hands-on operations.

3. Quick Start: Set Up Your Cloud Workbench in Three Steps

Step 1: Register and Access the Sealos Console

Open os.sealos.io (or the global site) and register with your email. Once logged in, you'll land on the Sealos main dashboard:

• Left sidebar: Functional categories like DevBox, Database, App Launchpad, App Store, etc.
• Right panel: Your projects and resource lists.

Why email instead of phone? Sealos is a global developer platform. Email is the most universal identity token, making future integrations with GitHub OAuth or SSO seamless. Plus, under the Sealos Sustainable Use License, personal use is completely free.

Step 2: Create a Cloud DevBox

Click DevBox on the left, then click "Create Development Environment". You'll see a list of language templates: Node.js, Python, Go, Java, etc.

How to choose? Pick your daily driver. For example, selecting Python pre-installs the Python runtime, pip, and essential toolchains, and launches a web-based VS Code / Cursor environment.

Once created, click "Open IDE" to start coding in your browser. Key takeaways here:

• Cloud Storage: All files live in the cloud. Switch devices and pick up right where you left off.
• Environment Isolation: Each DevBox is independent. Libraries installed in Project A won't conflict with Project B.
• Port Preview: Services running inside the DevBox can be directly previewed and accessed.

Step 3: Provision a Database

Go back to the console, click Database → Select your database type (MySQL / PostgreSQL / Redis / MongoDB) → Click Create.

Sealos automatically generates a connection address, username, password, and port. Copy these credentials and use them directly in your DevBox code.

## Example connection info for PostgreSQL after creation via Sealos Console
DB_HOST=pg-xxxxx.db.sealos.run
DB_PORT=5432
DB_USER=postgres
DB_PASSWORD=******
DB_NAME=default

Why not just run a MySQL container inside DevBox? You certainly can. But you'd have to handle data persistence, backups, and performance tuning yourself. Sealos's managed databases abstract this away: data is automatically persisted to cloud storage and supports horizontal scaling. For personal projects and small-to-medium teams, convenience is priority #1.

4. Hands-On Example: Deploy FastGPT (AI Knowledge Base) on Sealos

A dev environment and databases are great, but let's run a complete practical example: deploying FastGPT, an LLM-based AI knowledge base platform. Since FastGPT is already in the Sealos App Store, the process is straightforward.

Step 1: One-Click Deployment via App Store

On the main dashboard, click App Store, search for FastGPT, and open its detail page. You'll see deployment instructions and dependencies.

Click "One-Click Deploy". Sealos automatically provisions the required resources:

• A primary FastGPT application Pod
• A dependent PostgreSQL database (provisioned automatically if you haven't created one)
• A publicly accessible URL (Ingress is auto-configured)

What's happening under the hood? Sealos essentially generates the K8s YAML for a Deployment + Service + Ingress and applies it via the K8s API. But you don't need to care about that. A few clicks replace what used to take half an hour of manual deployment.

Step 2: Check Connection Info & Initialize

After deployment (usually 2-3 minutes), navigate to the database management page to see the newly created PostgreSQL instance. Copy the connection credentials and complete the initial setup in the FastGPT admin panel:

• Set up an admin account and password
• Configure your OpenAI API Key or other model provider keys
• Upload your knowledge base documents (supports PDF, TXT, Markdown, etc.)

Once initialized, you're ready to start RAG-powered conversations with FastGPT.

Step 3 (Advanced): Manually Deploy a Custom Docker Image

Want to deploy a service not in the App Store? Say, a simple Spring Boot app. Here's the path:

1. Click App Launchpad → New Application
2. Enter your Docker image URL (e.g., ghcr.io/your-project/app:latest)
3. Set the replica count (usually 1)
4. Configure port mapping and a domain (Sealos auto-generates the Ingress)
5. Click Deploy

The whole process takes about a minute. Core Principle: Sealos's App Launchpad is essentially a visual K8s Deployment creator. The form you fill out translates into the following K8s resources (good to know, but no need to write them yourself):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-spring-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-spring-app
  template:
    metadata:
      labels:
        app: my-spring-app
    spec:
      containers:
        - name: app
          image: ghcr.io/your-project/app:latest
          ports:
            - containerPort: 8080
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-spring-app-ingress
spec:
  rules:
    - host: my-app.sealos-example.run
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: my-spring-app-svc
                port:
                  number: 8080

You're just filling out a form; Sealos handles the YAML generation behind the scenes.

5. FAQ & Common Pitfalls

1. Where is the code I write in DevBox stored?
   It's stored in a cloud PersistentVolumeClaim (PVC). Even if you close the DevBox, your files remain. However, inactive instances may be suspended after a while to save resources. Always push critical code to Git.

2. Cannot connect to the database?

   • Ensure you're accessing the DB from within the DevBox. Sealos blocks direct external DB access by default (a security feature).
   • Double-check the host, port, username, and password you copied.
   • For Postgres, verify that the database name and schema match.

3. App returns 403/502 after deployment?
   Usually an Ingress misconfiguration. Verify that the port you set in App Launchpad matches the actual listening port inside your container. For example, if Spring Boot defaults to 8080 but you changed it in the container, the Ingress must be updated accordingly.

4. Can Sealos be used in production?
   Sealos is designed to lower the barrier to cloud infrastructure. Many teams already run production-grade AI services on it. However, if you need fine-grained resource control, advanced network policies, or custom high-availability architectures, self-managed K8s clusters are still recommended. Sealos shines for: personal workbenches, rapid prototyping, and full-stack dev environments for small-to-medium teams.

5. About the License
   Sealos uses a custom Sealos Sustainable Use License. It permits internal business use and personal non-commercial use, but prohibits reselling it as a cloud service to third parties. For personal or internal company use, you're completely fine.

6. Conclusion

In this tutorial, we accomplished four things:

1. Registered on Sealos and accessed the console
2. Created a DevBox cloud desktop for an in-browser development environment
3. Provisioned managed databases (MySQL / PostgreSQL / Redis) with one click
4. Deployed the FastGPT AI app via the App Store, and deployed a custom Docker image via App Launchpad

We achieved all of this without writing a single line of YAML or installing a single local service. The result? A cloud development workbench you can access anytime, anywhere. For backend developers, this finally means replacing "environment configuration time" with "business logic coding time".

If you want to dive deeper:

• Try building and deploying code directly via Dockerfile in App Launcher
• Explore Sealos's S3 object storage for static assets and file hosting
• Check out Sealos's public Roadmap to see what's next
• For more K8s internals, explore the FastGPT source code (built by the same team)

Sealos on GitHub: labring/sealos

Have you run into any pitfalls or have deployment tips? Share your experiences in the comments!