DEV Community: Seal

Building Your Private ChatGPT and Knowledge Base with AnythingLLM and GPUStack

Seal — Tue, 12 Nov 2024 04:27:09 +0000

AnythingLLM [https://github.com/Mintplex-Labs/anything-llm] is an all-in-one AI application that runs on Mac, Windows, and Linux. Its goal is to enable the local creation of a personal ChatGPT using either commercial or open-source LLMs along with vector database solutions. AnythingLLM goes beyond being a simple chatbot by including Retrieval-Augmented Generation (RAG) and Agent capabilities. These features allow it to perform a variety of tasks, such as fetching website information, generating charts, summarizing documents, and more.

AnythingLLM can integrate various types of documents into different workspaces, enabling users to reference document content during chats. This provides a easy way to organize workspaces for different tasks and documents.

In this article, we will introduce how to build a personal ChatGPT with knowledge base using AnythingLLM + GPUStack.

Run models with GPUStack

GPUStack is an open-source GPU cluster manager for running large language models (LLMs). It enables you to create a unified cluster from GPUs across various platforms, including Apple MacBooks, Windows PCs, and Linux servers. Administrators can deploy LLMs from popular repositories like Hugging Face, allowing developers to access these models as easily as they would access public LLM services from providers such as OpenAI or Microsoft Azure.

Unlike Ollama, GPUStack is a cluster solution designed to aggregate GPU resources from multiple devices to run models.

To deploy the Chat Model and Embedding Model on GPUStack:

• Chat Model: llama3.1

• Embedding Model: bge-m3

And you need to create an API key. This key will be used by AnythingLLM to authenticate when accessing the models API deployed on GPUStack.

Install and configure AnythingLLM

AnythingLLM offers packages for Mac, Windows, and Linux, you can download from https://anythingllm.com/download. After installation, open AnythingLLM to begin the setup process.

Configure LLM Provider

First, configure the chat model. Search for OpenAI, select Generic OpenAI:

And fill in the details for the model deployed on GPUStack:

Save and configure embedding model.

Configure Embedding Provider

AnythingLLM includes a lightweight embedding model, all-MiniLM-L6-v2, which offers limited performance and context length. For more powerful embedding capabilities, you can either opt for public embedding services or run open-source embedding models. Here, we’ll configure the embedding model bge-m3, which is running on GPUStack. Set the embedding provider to Generic OpenAI and fill in the relevant configuration.

Then create a workspace, and we can use AnythingLLM after it's completed.

Use AnythingLLM

Chat with LLM

Select a workspace, create a new thread, and send your question to the LLM:

Fetch website content

Click the upload button next to the workspace, enter the website URL in the Fetch website box, and fetch the website content.

The fetched website content will be sent to the embedding model for vectorization and then stored in the vector database.

Check the content fetched from the website:

Documents embedding

Click the upload button next to the workspace, then click the upload box and upload a document. The document will be sent to the embedding model for vectorization and then stored in the vector database.

Check the content of embedded documents:

For more information, please read the AnythingLLM documentation: https://docs.anythingllm.com/

Conclusion

In this tutorial, we have introduced how to use AnythingLLM + GPUStack to aggregate GPUs across multiple devices and build an all-in-one AI application for RAG and AI Agents.

GPUStack provides a standard OpenAI-compatible API, which can be quickly and smoothly integrated with various LLM ecosystem components. Wanna give it a go? Try to integrate your tools/frameworks/software with GPUStack now and share with us!

If you encounter any issues while integrating GPUStack with third parties, feel free to join GPUStack Discord Community and get support from our engineers.

Building Free GitHub Copilot Alternative with Continue + GPUStack

Seal — Fri, 23 Aug 2024 17:00:00 +0000

Click here to read original post

Continue is an open-source alternative to GitHub Copilot, this is an open-source AI coding assistant that allows to connect various large language models(LLMs) within VS Code and JetBrains to build custom code autocompletion and chat capabilities. It supports:

Code parsing
Code autocompletion
Code optimization suggestions
Code refactoring
Code implementations Inquiring
Documentation online searching
Terminal errors parsing

and more. It assists developers in coding and enhancing their development efficiency.

In this tutorial, we are going to use Continue + GPUStack to build a free GitHub Copilot locally, providing developers with an AI-paired programming experience.

Running Models with GPUStack

First, we will deploy the models on GPUStack. There are three model types recommended by Continue:

Chat model: select llama3.1, this is the latest open-source model trained by Meta.
Autocompletion model: select starcoder2:3b, a highly advanced autocompletion model trained by Hugging Face.
Embedding model: select nomic-embed-text, which supports a context length of 8192 tokens, it outperforms OpenAI ada-002 and text-embedding-3-small models for both short and long context tasks.

After deploying the models, you are also required to create an API key in the API Keys section for authentication when Continue accesses the models deployed on GPUStack.

Installing and Configuring Continue

Continue provides extensions for both VS Code and JetBrains. In this article, we will use VS Code as an example. Install Continue from the VS Code extension store:

Once installed, drag the Continue extension to the right panel to avoid conflict with the file explorer:

Then, select the settings button in the bottom-right corner to edit Continue's configuration and connect to the models deployed on GPUStack. Replace the sections for "models", "tabAutocompleteModel", and "embeddingsProvider" with your own GPUStack-generated API Key:

{
  "models": [
    {
      "title": "Llama 3.1",
      "provider": "openai",
      "model": "llama3.1",
      "apiBase": "http://192.168.50.4/v1-openai",
      "apiKey": "gpustack_f58451c1c04d8f14_c7e8fb2213af93062b4e87fa3c319005"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Starcoder 2 3b",
    "provider": "openai",
    "model": "starcoder2",
    "apiBase": "http://192.168.50.4/v1-openai",
    "apiKey": "gpustack_f58451c1c04d8f14_c7e8fb2213af93062b4e87fa3c319005"
  },
  "embeddingsProvider": {
    "provider": "openai",
    "model": "nomic-embed-text",
    "apiBase": "http://192.168.50.4/v1-openai",
    "apiKey": "gpustack_f58451c1c04d8f14_c7e8fb2213af93062b4e87fa3c319005"
  }
}

Get to Use Continue

After configuring Continue to connect to the GPUStack-deployed models, go to the top-right corner of the Continue plugin interface and select Llama 3.1 model. Now you are able to use the features we mentioned at the beginning of this tutorial:

Code Parsing: Select the code, press Cmd/Ctrl + L, and enter a prompt to let the local LLM parse the code:
Code Autocompletion: While coding, press Tab to let the local LLM attempt to autocomplete the code:
Code Refactoring: Select the code, press Cmd/Ctrl + I, and enter a prompt to let the local LLM attempt to optimize the code:

The LLM will provide suggestions, and you can decide whether to accept or reject them:

Inquire About Code Implementation: You can try @Codebase to ask questions about the codebase, such as how a certain feature is implemented:
Documentation Search: Use @Docs and select the document site you wish to search for and ask your questions, enabling you to find the results you need:

For more information, please read the official Continue documentation: https://docs.continue.dev/how-to-use-continue

Conclusion

In this tutorial, we have introduced how to use Continue + GPUStack to build a free local GitHub Copilot, offering AI-paired programming capabilities at no cost to developers.

If you encounter any issues while integrating GPUStack with third parties, feel free to join GPUStack Discord Community and get support from our engineers.

Introducing GPUStack: An open-source GPU cluster manager for running LLMs

Seal — Fri, 26 Jul 2024 15:36:39 +0000

What is GPUStack?

We are thrilled to launch GPUStack, an open-source GPU cluster manager for running Large Language Models (LLMs). Even though LLMs are widely available as public cloud services, organizations cannot easily host their own LLM deployments for private use. They need to install and manage complex clustering software such as Kubernetes and then figure out how to install and manage the AI tool stack on top. Popular ways to run LLMs locally, such as LMStudio and LocalAI, works on a single machine.

GPUStack allows you to create a unified cluster from any brand of GPUs in Apple MacBooks, Windows PCs, and Linux servers. Administrators can deploy LLMs from popular repositories such as Hugging Face. Developers can then access LLMs just as easily as accessing public LLM services from vendors like OpenAI or Microsoft Azure.

For more details about GPUStack, visit:

GitHub repo: https://github.com/gpustack/gpustack

User guide: https://docs.gpustack.ai

Why GPUStack?

Today, organizations who want to host LLMs on a cluster of GPU servers have to do a lot of work to integrate a complex software stack. By using GPUStack, organizations no longer need to worry about cluster management, GPU optimization, LLM interference engines, usage and metering, user management, API access, and dashboard UI. GPUStack is a complete software platform for building your own LLM-as-a-Service (LLMaaS).

As the following figure illustrates, the admin deploys models into GPUStack from a repository like HuggingFace, and then developers can connect to GPUStack to use these models in their applications.

Key features of GPUStack

GPU cluster setup and resource aggregation

GPUStack aggregates all GPU resources within a cluster. It is designed to support all GPU vendors, including Nvidia, Apple, AMD, Intel, Qualcomm, and others. GPUStack is compatible with a laptops, desktops, workstations, and servers running MacOS, Windows, and Linux.

The initial release of GPUStack supports Windows PCs and Linux servers with Nvidia graphics cards, and Apple Macs.

Deployment and Inference for Models

GPUStack supports distributed deployment and inference of LLMs across a cluster of GPU machines.

GPUStack selects the best inference engine for running the given LLM on the given GPU. The first LLM inference engine supported by GPUStack is LLaMA.cpp, which allows GPUStack to support GGUF models from Hugging Face and all models listed in the Ollama library (ollama.com/library).

You can run any model on GPUStack by first converting it to GGUF format and uploading it to Hugging Face or Ollama library.

Support of other inference engines, such as vLLM, is on our roadmap and will be provided in the future.

Note: GPUStack will automatically schedule the model you select to run on machines with appropriate resources, relieving you of manual intervention. If you want to assess the resource consumption of your chosen model, you can use our GGUF Parser project: https://github.com/gpustack/gguf-parser-go. We intend to provide more detailed tutorials in the future.

Although GPU acceleration is recommended for inference, we also support CPU inference, though the performance isn't as good as GPU. Alternatively, using a mix of GPU and CPU for inference can maximize resource utilization, which is particularly useful in edge or resource-constrained environments.

Easy integration with your applications

GPUStack offers OpenAI-compatible APIs and provides an LLM playground along with API keys. The playground enables AI developers to experiment with and customize your LLMs, and seamlessly integrate them into AI-enabled applications.

Additionally, you can use the metrics GPUStack provides to understand how your AI applications utilize various LLMs. This helps administrators manage GPU resource consumption effectively.

Observability metrics for GPUs and LLMs

GPUStack provides comprehensive metrics performance, utilization, and status monitoring.

For GPUs, administrators can use GPUStack to monitor real-time resource utilization and system status. Based on these metrics:

Administrators perform scaling, optimization, and other maintenance operations.
GPUStack adjusts its model scheduling algorithm.

For LLMs, developers can use GPUStack to access metrics like token throughput, token usage, and API request throughput. These metrics help developers evaluate model performance and optimize their applications. GPUStack plans to support auto-scaling based on these inference performance metrics in future releases.

Authentication and access control

GPUStack also provides authentication and role-based access control (RBAC) for enterprises. Users on the platform can have either admin or regular user roles. This guarantees that only authorized administrators can deploy and manage LLMs and that only authorized developers can utilize them.

GPUStack Use Cases

GPUStack unlocks a world of possibilities for running LLMs on any GPU vendors. Here are just a few examples of what you can achieve with GPUStack:

Aggregate existing MacBooks, Windows PCs, and other GPU resources to offer a low-cost LLMaaS for a development team.
In limited resource environments, aggregate multiple edge nodes to provide LLMaaS on CPU resources.
Create your own enterprise-wide LLMaaS in your own data center for highly sensitive workloads that cannot be hosted in a cloud.

Getting Started with GPUStack

Installation

Linux or MacOS

GPUStack provides a script to install it as a service on systemd or launchd based systems. To install GPUStack using this method, execute:

curl -sfL https://get.gpustack.ai | sh -

Now you have deployed and started the GPUStack server, which serves as the first worker node. You can access the GPUStack page via http://myserver (Replace with the IP address or domain of the host you installed).

Log in to GPUStack with username admin and the default password. You can run the following command to get the password for the default setup:

cat /var/lib/gpustack/initial_admin_password

To add additional worker nodes and form a GPUStack cluster, please run the following command on each worker node:

curl -sfL https://get.gpustack.ai | sh - --server-url http://myserver --token mytoken

Replace http://myserver with your GPUStack server URL and mytoken with your secret token for adding workers. To retrieve the token in the default setup from the GPUStack server, use the following command:

cat /var/lib/gpustack/token

Or follow the instructions on GPUStack to add workers:

Windows

Run PowerShell as administrator, then run the following command to install GPUStack:

Invoke-Expression (Invoke-WebRequest -Uri "https://get.gpustack.ai" -UseBasicParsing).Content

You can access the GPUStack page via http://myserver (Replace with the IP address or domain of the host you installed).

Log in to GPUStack with username admin and the default password. You can run the following command to get the password for the default setup:

Get-Content -Path (Join-Path -Path $env:APPDATA -ChildPath "gpustack\initial_admin_password") -Raw

Optionally, you can add extra workers to form a GPUStack cluster by running the following command on other nodes:

Invoke-Expression "& { $((Invoke-WebRequest -Uri "https://get.gpustack.ai" -UseBasicParsing).Content) } -ServerURL http://myserver -Token mytoken"

In the default setup, you can run the following to get the token used for adding workers:

Get-Content -Path (Join-Path -Path $env:APPDATA -ChildPath "gpustack\token") -Raw

For other installation scenarios, please refer to our installation documentation at: https://docs.gpustack.ai/docs/quickstart

Serving LLMs

As an LLM administrator, you can log in to GPUStack as the default system admin, navigate to Resources to monitor your GPU status and capacities, and then go to Models to deploy any open-source LLM into the GPUStack cluster. This enables you to provide these LLMs to regular users for integration into their applications. This approach helps you to efficiently utilize your existing resources and deliver stable LLM services for various needs and scenarios.

Access GPUStack to deploy the LLMs you need. Choose models from Hugging Face (only GGUF format is currently supported) or Ollama Library, download them to your local environment, and run the LLMs:

GPUStack will automatically schedule the model to run on the appropriate Worker:

You can manage and maintain LLMs by checking API requests, token consumption, token throughput, resource utilization status, and more. This helps you decide whether to scale up or upgrade LLMs to ensure service stability.

Integrating with your applications

As an AI application developer, you can log in to GPUStack as a regular user and navigate to Playground from the menu. Here, you can interact with the LLM using the UI playground.

Next, visit API Keys to generate and save your API key. Return to Playground to customize your LLM by adjusting the system prompt, adding few-shot learning examples, or resizing prompt parameters. When you're done, click View Code and select your preferred code format (curl, Python, Node.js) along with the API key. Use this code in your applications to enable communication with your private LLMs.

you can access the OpenAI-compatible API now, for example, use curl as the following:

export GPUSTACK_API_KEY=myapikey
curl http://myserver/v1-openai/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $GPUSTACK_API_KEY" \
  -d '{
    "model": "llama3",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "Hello!"
      }
    ],
    "stream": true
  }'

Join Our Community

Please find more information about GPUStack at: https://gpustack.ai.

If you encounter any issues or have suggestions for GPUStack, feel free to join our Community for support from the GPUStack team and to connect with fellow users globally.

We are actively enhancing the GPUStack project and plan to introduce new features in the near future, including support for multimodal models, additional accelerators like AMD ROCm or Intel oneAPI, and more inference engines. Before getting started, we encourage you to follow and star our project on GitHub at gpustack/gpustack to receive instant notifications about all future releases. We welcome your contributions to the project.

About Us

GPUStack is brought to you by Seal, Inc., a team dedicated to enabling AI access for all. Our mission is to enable enterprises to use AI to conduct their business, and GPUStack is a significant step towards achieving that goal.

Quickly build your own LLMaaS platform with GPUStack! Start experiencing the ease of creating GPU clusters locally, running and using LLMs, and integrating them into your applications.

How to Enhance Developer Productivity with Platform Engineering

Seal — Wed, 24 Apr 2024 15:07:00 +0000

As the cloud computing, and GenAI technologies continue to evolve, the software industry faces increasingly fierce competition. Simultaneously, software development has become more complex. Developers need to acquire more knowledge and skills while dealing with additional problems and risks.

To address these challenges, development teams must deliver valuable software products quickly, efficiently, and cost-effectively. They must also approach problem-solving with simplicity, optimization, and innovation. This is precisely why discussions around development efficiency have become a hot topic.

In this article, we will explore the definition and challenges of developer productivity, as well as how platform engineering can help organizations improve their efficiency.

What is Developer Productivity?

Developer productivity is defined as the ability of a development team to deliver higher-quality, more reliable, and sustainable business value in a more efficient manner. This is a critical focus area for both emerging technology companies and traditional software enterprises because it directly impacts competitiveness and innovation.

As the market changes rapidly, organizations that fail to adapt their development efficiency risk falling behind competitors and eventually being phased out.

Challenges in Improving Developer Productivity

However, enhancing developer productivity is a challenging endeavor. With the continuous growth in software scale and complexity, expanding development team sizes, and accelerating business requirements and market changes, the path to improving development efficiency faces several challenges:

1. Technical Complexity: As technology evolves, the technical complexity of products increases, thereby raising the technical bar for development. Modern software architectures consist of multiple layers, technologies, and services, demanding end-to-end understanding from developers. This complexity adds cognitive load and increases the risk of errors and inefficiencies. Overcoming technical complexity requires substantial resource investment to ensure both efficiency and quality.

2. Project Management Difficulty: The complexity and scale of projects inevitably lead to greater project management challenges. Enterprises require robust project management systems and tools to coordinate and manage the activities of various development teams and project timelines. Additionally, fostering efficient teamwork and communication is crucial to ensuring projects are completed on time and with high quality.

3. Technical Debt: Many organizations encounter difficulties in adopting DevOps, cloud-native technologies, and other advanced approaches due to the challenges posed by legacy systems and outdated practices. These difficulties result in technical debt and skill gaps, which in turn impede the delivery of software at a faster and more optimal pace.

4. Lack of Standardization: Enterprises often have multiple development teams using different tools and configurations for their applications and infrastructure. This lack of standardization creates silos and inconsistencies, making collaboration, sharing best practices, and ensuring quality and security more challenging.

5. Low Productivity: Developers spend significant time on non-value-added tasks such as environment setup, tool configuration, and debugging. This reduces their productivity and focus on delivering customer value.

6. Lack of Continuous Improvement and Feedback Loop:The improvement of development efficiency is a long-term project that requires continuous optimization. Without effective mechanisms and a culture of improvement and feedback within the organization, it is difficult to achieve sustained development efficiency gains.

How Platform Engineering Boosts Developer Productivity

Platform engineering is a systematic approach aimed at improving software development efficiency and quality. By building reusable, scalable software platforms, platform engineering provides development teams with standardized development frameworks and tools. It optimizes collaboration and communication, enhances software testability and maintainability, and supports rapid iteration and innovation. Let's explore these aspects in more details:

Standardized Development Frameworks and Tools:

Platform engineering offers standardized development frameworks and tools, including code libraries, components, and templates. These enable teams to develop high-quality software more quickly, reducing developers' workload and time costs.

Consistent frameworks and tools ensure everyone follows the same best practices and standards, improving efficiency, reducing errors, and minimizing technical disparities among team members. For specific industries, teams can leverage existing platforms and components without redeveloping all infrastructure, allowing developers to focus on core business logic.

Optimized Team Collaboration and Communication:

Platform engineering provides standardized development processes and specifications, unifying team development methods and approaches. This reduces communication and coordination costs, enhancing collaboration efficiency.

Centralized communication and coordination platforms (such as shared task lists, code repositories, documentation, and team discussions) allow developers to better understand each other's progress and challenges. This facilitates quick collaboration and issue resolution, ultimately improving team communication and efficiency.

Improved Software Testability and Maintainability:

Platform engineering employs a range of techniques, including automated testing, code refactoring, and performance monitoring, with the objective of enhancing the testability and maintainability of software. This approach has the potential to reduce the burden on developers and the incidence of errors, thereby improving the efficiency, quality, and reliability of software development.

Common code libraries and documentation provided by platform engineering help teams maintain and upgrade software effectively.

Support for Rapid Iteration and Innovation:

The provision of reusable templates and components by platform engineering enables development teams to implement new ideas and features in a more expeditious manner. Furthermore, it facilitates rapid iteration and updates, thereby enabling businesses to gain a deeper understanding of user needs and behavior. This, in turn, enhances the user experience and market competitiveness.

Additionally, platform engineering enhances traceability and transparency in the development process. Developers gain clearer insights into their tasks and goals, as well as the overall development status. By enabling rapid innovation and progress within teams, platform engineering facilitates enhanced development efficiency.

Conclusion

In conclusion, platform engineering offers several advantages for improving developer productivity and is a crucial approach for businesses seeking to enhance their development processes. As digital transformation continues, it can be expected that platform engineering will play an increasingly important role in enterprise development. In the future, platform engineering will continue to evolve and find applications in various areas, including multi-cloud environments, automation, and AI technology integration.

Walrus is an open-source application management platform based on IaC, that helps platform engineers build golden paths for developers and empowers developers with self-service capabilities. Its abstraction layers allow developers to leverage standardized and reusable IaC templates for self-service resource provisioning and deployments without being infrastructure expertise.

If you want to discuss more with us, welcome to join Seal Discord to share your thoughts and feedback.

Platform as a Product: Why do we need?

Seal — Thu, 18 Apr 2024 15:00:00 +0000

In today's fast-paced digital age, businesses are constantly seeking innovative ways to deliver value and drive growth. The concept of Platform as a Product (PaaP) has gained widespread attention.

With the advancement of technology, traditional product-centric approaches are being replaced by more comprehensive, platform-based strategies. This article aims to delve into the concept of Platform as a Product, exploring its meaning, characteristics, advantages, and challenges.

What is Platform as a Product?

Platform as a Product refers to a business model where a company creates and provides a platform that allows various stakeholders, including developers, third-party providers, and end-users, to build, customize, and distribute their own products or services. Unlike traditional products designed for end-users, PaaP serves as a foundation upon which others can develop and deliver their own products.

Key Characteristics of Platform as a Product

Platform as a Product represents a shift in how businesses create value and interact with developers, partners, and users. By leveraging the characteristics of Platform as a Product, businesses can gain a competitive edge. Here, we summarize the five key characteristics of Platform as a Product.

Infrastructure and Technology Stack

At the core of Platform as a Product is a robust infrastructure and technology stack. This includes the hardware, software frameworks, APIs, and developer tools that constitute the foundation for building and operating the platform.

The infrastructure must be scalable, reliable, and capable of handling the diverse and growing needs of a varied user base and ecosystem. The technology stack facilitates seamless integration, enabling developers to leverage existing platform features and providing a consistent and secure environment for application development and deployment.

Open and Collaboration

One of the key features of Platform as a Product is that it is open to external developers, partners, and users. Open fosters collaboration, knowledge sharing, and innovation within the platform ecosystem. Companies provide accessible APIs, SDKs, and developer communities and encourage participation and contribution. By embracing open, the platform nurtures a vibrant ecosystem where developers and partners can build on top of the platform, extend its functionalities, and create value-added products and services. Collaboration within the ecosystem amplifies the platform's overall value proposition and enhances its competitive advantage.

Scalability and Flexibility

Scalability is also a key characteristic of a successful PaaP model. The platform's design must be able to handle exponential growth, accommodate an increasing number of users, and support a wide range of applications and services. Scalability ensures that the platform can meet the evolving needs of its user base without impacting performance or user experience.

Flexibility is another important aspect of PaaP. The platform should offer customization options, allowing developers to tailor the platform's functionalities according to their specific requirements. Customization enhances the platform's appeal, improves user satisfaction, and supports the creation of unique applications and services that cater to different needs.

Resources and Support for Developers

To attract developers, successful PaaP models provide comprehensive developer empowerment and support. This includes documentation, tutorials, sample code, and developer communities that facilitate knowledge exchange, troubleshooting, and collaboration.

Organizations that prioritize providing resources and support for developers create an atmosphere where developers can thrive, experiment, and innovate. By providing the necessary resources and tools, the platform can attract top talent, accelerate development cycles, and drive ecosystem growth.

Advantages and Potential of Platform as a Product

The adoption of the PaaP model changes the way businesses create value, attract developers and other stakeholders, and provide innovative solutions. By adopting the PaaP model, businesses stand to gain 3 major advantages and potential.

One of the advantages that PaaP brings to businesses is tha*t it fosters accelerated innovation*. By providing platform infrastructure, tools, and APIs, developers and partners can focus on building innovative products and services. This approach allows developers to leverage existing platform features and reduces the time and effort required to develop core functionalities. As a result, PaaP enables companies to quickly bring new products to market, iterate based on user feedback, and maintain a competitive edge.

A platform as a product has the ability to attract a diverse array of developers, partners, and users, thereby creating a vibrant ecosystem. These ecosystems can foster collaboration, knowledge exchange, and the creation of value-added services. By opening their platforms to external contributors, companies can harvest and leverage a broader range of talent, ideas, and resources. The expanded ecosystem not only enhances the platform's functionalities but also opens new revenue streams, drives user engagement, and fosters community awareness.

Platform as a Product aims to deliver an excellent user experience. By integrating various services, features, and applications into a unified platform, users can access a comprehensive solution that simplifies their interactions, streamlines processes, and reduces friction. Through seamless integration, intuitive interfaces, and personalized experiences, PaaP improves user satisfaction and loyalty. Additionally, as the ecosystem expands, users benefit from the continuous innovation and enrichment brought about by the contributions of developers and partners within the platform.

Challenges Faced by Platform as a Product

While PaaP models offer many benefits and transformative opportunities for organizations, they also present unique challenges that must be strategically addressed. Implementing and managing a successful PaaP requires careful planning, continuous adjustment, and a customer-centric approach.

PaaP platforms typically involve complex technical architectures, integration challenges, and scalability requirements. Building and maintaining a robust and scalable infrastructure requires substantial resources and expertise. Companies need to invest in skilled technical teams, adopt agile development methodologies, and leverage cloud-based technologies to successfully overcome technical complexity. Collaborating with developers and partners can also help address technical challenges and ensure compatibility and interoperability within the ecosystem.

Another major challenge for PaaP is establishing effective governance and regulatory mechanisms. As platforms open to external developers, partners, and users, ensuring fair competition, content quality, data privacy, and ethical standards becomes paramount. Companies must establish policies, guidelines, and mechanisms to effectively monitor and regulate the platform ecosystem. This includes content review, dispute resolution, enforcing compliance, and maintaining user trust. Therefore, striking a balance between platform openness and governance of responsibilities is a key challenge to be addressed.

As PaaP becomes more popular, competition among platform providers will intensify. Businesses wanting to stand out in the industry need to attract and retain users and developers. Establishing a strong brand, providing an excellent user experience, and offering comprehensive developer support are basic strategies for maintaining a leading position, so businesses face the challenge of creating platform stickiness. Businesses can try to cultivate a vibrant ecosystem, foster loyalty through incentives or rewards, and continuously innovate to provide new valuable features.

Conclusion

Platform as a Product has emerged as a transformative business model. By creating a foundation on which developers and users can build their own products and services, PaaP fosters innovation, ecosystem expansion, and enhanced user experience. While challenges exist, the benefits of PaaP are undeniable, and these benefits bring advantages to businesses, making PaaP increasingly attractive to enterprises across various industries. With the continuous advancement of technology, we can expect the continued development and adoption of Platform as a Product, becoming a key driver of digital transformation.

If you are interested in Platform engineering, Welcome to our community:

Discord: https://discord.gg/fXZUKK2baF
Twitter/X: https://twitter.com/Seal_io
LinkedIn: https://www.linkedin.com/company/seal-io
Youtube: https://www.youtube.com/@Seal-io

Walrus vs. Terraform Enterprise: Expand your IaC to Kubernetes ecosystem!

Seal — Mon, 08 Apr 2024 13:47:40 +0000

Terraform, with its Enterprise and Cloud offerings, has been a reliable platform for organizations to deploy and manage infrastructure in the dynamic world of Infrastructure as Code (IaC).

However, as user needs and preferences shift, organizations are exploring alternatives to Terraform Cloud/Enterprise driven by cost concerns, flexibility requirements, and the imperative to streamline complexity.

While Terraform Cloud/Enterprise remains a prevalent choice, it possesses certain limitations that Walrus effectively addresses. This article outlines the main differences between the two tools based on the following factors:

Abstraction and Flexibility
Environments management
Ecosystems and extensibility
Licensing

What is Walrus?

Walrus is an open-source application platform based on IaC tools, including OpenTofu, Terraform and others, that ochestrates your entire application systems (including application services and resource dependencies) and enables developers with self-service capabilities.

Walrus simplifies Kubernetes and other infrastructure management by using a unified abstraction layer called Resource Definition. DevOps teams create this layer, which combines IaC templates, matching rules, pre-set parameters, and UI Schema. This enables developers to self-deploy infrastructures that meet cost, operational, and security requirements. With this feature, you can deploy an application to multiple infrastructures or environments simultaneously.

One of the main advantages of Walrus is its ability to simplify environment and resource management in a single pane of glass. Specifically, Walrus offers a clear dependency graph within the system and collects resource operations in a single view. This eliminates the need to switch between different windows, improving the overall experience and making it easier to handle complex resource management tasks.

What is Terraform Cloud/Enterprise?

Terraform Cloud is a platform developed by Hashicorp that helps with managing your Terraform code. It is used to enhance collaboration between developers and DevOps engineers, simplify your workflow, and improve overall security around the product.

Terraform Enterprise is a self-hosted distribution of Terraform Cloud. It offers enterprises a private instance of the Terraform Cloud application, with no resource limits and with additional enterprise-grade architectural features like audit logging and SAML single sign-on.

Walrus and Terraform Enterprise Differences

Abstraction and Flexibility

Walrus has two layers of abstraction: IaC templates (including Terraform modules) and Resource Definition, whereas Terraform Cloud/Enterprise offers a single abstraction layer, Terraform module.

With Walrus, operators can set up IaC templates that developers can leverage for self-service resource provisioning and deployments. Furthermore, Resource Definition empowers operators to establish and enforce corporate policies, dictating the usage, configuration, and deployment permissions of cloud resources. Consequently, developers are freed from the intricacies of deploying suitable infrastructure for their applications, enabling them to concentrate on coding.

This architecture allows Walrus to maintain Terraform code DRY (Don't Repeat Yourself), ensuring a unified abstraction across platforms and clouds without exposing technical intricacies to end-users. We will post a blog to give more details on how this architecture works. Stay tuned!

What's more, Walrus provides UI schema and HCL validation as input controls, which is an advantage over Terraform Cloud/Enterprise's HCL-only provision. Customizing the UI schema helps personalize the user interface and reduce configuration complexity.

Environments Management

Unlike Terraform Cloud/Enterprise's workspace, which is confined to a single Terraform module, Walrus provides a more flexible approach to infrastructure management. Walrus introduces the concept of Environment, which allows resources to exist as individual Terraform modules managed independently within an environment. This setup enables users to orchestrate multiple modules, sidestepping the complexity associated with managing large modules and facilitating infrastructure management akin to microservices.

Ecosystems and Extensibility

Walrus has a flexible architecture and an extensive ecosystem. It supports Terraform and OpenTofu, as well as seamlessly integrating various CD tools for GitOps implementation, such as ArgoCD and FluxCD. Furthermore, it officially supports Argo Workflow as a workflow engine, making it easy to integrate within diverse environments, including the Kubernetes ecosystem. Walrus can assist in expanding your IaC management to the Kubernetes ecosystem and utilizing its capabilities to achieve your goals.

Conversely, Terraform Cloud/Enterprise, being vendor-locked within the HashiCorp ecosystem, confines GitOps solutions to proprietary realms, limiting workflow flexibility.

Licensing

Walrus is 100% open source, following the Apache 2.0 license. In contrast, the community edition of Terraform changed its license to BSL last year, and the enterprise/cloud edition is proprietary.

Conclusion

Walrus offers more than just Terraform capabilities. It follows the methodology of platform engineering to simplify complexity for both developers and operations. In the future, Walrus will support Kubernetes architecture, heralding a paradigm shift whereby Kubernetes CRD will serve as a unified abstraction layer for deploying applications across infrastructures or environments at once. For cloud-native engineers, this enhancement holds the promise of significantly reducing cognitive loads.

It is 100% open source, welcome to give it a try!

If you are interested in Walrus, Welcome to our community:

Discord: https://discord.gg/fXZUKK2baF

Twitter/X: https://twitter.com/Seal_io

LinkedIn: https://www.linkedin.com/company/seal-io

Youtube: https://www.youtube.com/@Seal-io

[Video]Give a try to deploy your own Super Mario with Walrus!

Seal — Fri, 15 Mar 2024 03:39:14 +0000

How to Deploy MySQL across Multiple Infrastructures easily with Walrus

Seal — Thu, 14 Mar 2024 03:52:07 +0000

In Walrus, operators declare the types of resources to be provided in the Resource Definition. They then apply different resource deployment templates to various types of environments and projects by setting up matching rules. Developers do not need to focus on the specific implementation of the underlying layer. By creating Resource objects to declare the types of resources needed and their basic information, they can flexibly automate the creation of required resources and use them in various environments. This shields the complexity of the infrastructure of different environments and reduces the cognitive burden on researchers and developers.

This tutorial will use a MySQL database as an example and show how to quickly deploy an application to different environments with Walrus by configuring two API objects: Resource Definition and Resource.

What is Resource Definition?

To begin, let's clarify some of the concepts involved.Resource Definitions are central to Walrus' approach to creating a unified abstraction of the upper layers of a multi-cloud, hybrid infrastructure. This approach simplifies deployment configuration.

Similar to the concept of multi-architecture in containers, this allows the same image to contain different architectures of the image Manifest configuration. The image is acquired according to the actual environment, automatically selecting the appropriate image, enabling seamless switching of containers on different hardware.

Walrus Resource Definition serves as the Manifest in the deployment process. It includes the configuration of various rules and automatically selects the appropriate deployment template based on the environment during deployment.

The Resource Definition consists of 4 parts:

Template: The configuration required to create resources through customization or abstraction using open source templates.
Matching rule: Define the matching conditions for each rule and the template to be used when the conditions are met.
Admin Predefined Config: Simplify user configuration at deployment time by adding predefined configurations such as administrative configurations, best practices, etc. under matching rules.
UI Schema: Hide complexity with customized user interface styles based on requirements.

Now let's take a look at how you can leverage resource definitions to shield complexity and deploy applications across multiple infrastructures.

How to Deploy Applications across multiple infrastructures

Prerequisites

Before you begin, prepare the appropriate resources, and complete the following configuration tasks.

1.Connector configuration

Go to Default Project > Connectors > New Connector, enter the name aws, select the connector of the cloud provider type, select AWS for the type, select Production for the applicable environment type, and enter other information to complete the configuration.

Click New Connector again, enter the name alibaba, select Alibaba for the type, select Production for the applicable environment type, and enter other information to complete the configuration.

2.Prepare the environments

Go to Default Project > Environment > New Environment, enter production as the name, and associate the newly created connector named aws with the production deployment environment.

Create another new environment, enter the name dr, and associate it with the connector named alibaba, which will be used as the cloud disaster recovery environment. Together with the local environment that comes with the default project, we now have a total of three environments: local, production, and dr.

3. Download Walrus CLI

Configure Resource Definition

This is an example of deploying a MySQL database.

1.Resource Definition Matching Rules

Go to Operations > Resource Definition and select New Resource Definition.

Enter the name as demo-mysql and select the type as MySQL.

Create New Matching Rule. dev is utilized to specify the match rules and templates for the development environment. Please add a selector and select the environment name as local. Use the latest version of builtin/kubernetes-mysql for the template and match the CPU and memory resources in the predefined configuration section.

The production one represents the production environment. To add a selector, select the environment name and enter production. The template utilizes the latest version of builtin/aws-rds-mysql. In the predefined configuration section, match the Vpc Id so that you don't need to fill it in when creating resources using this resource definition. Other configurations should be based on the actual situation.

The matching rule dr represents the disaster recovery environment. To select this environment, add a selector and enter dr as the environment name. Use the latest version of builtin/alicloud-rds-mysql for the template. Match the Vpc Id in the predefined configuration section and configure the remaining settings according to the actual situation.

2.Customize UI Schema

After configuring the rules, Walrus will automatically generate UI schema based on the configuration and predefined settings. Administrators can then customize the UI schema to their specific needs.

To view the generated UI schema, go to Operations > Resource Definition, find the corresponding Resource Definition and preview UI Schema. We have simplified the configurations by removing the complex ones and only including the common configurations. This will help users spin up quickly. Below is the finalized UI Schema:

Deploy MySQL across Multiple Environments

The configured resource definitions will aid in application deployment across the infrastructure.

Navigate to Applications> Local Environment > New Resource.
Enter the resource name, select the resource type as MySQL, specify the architecture, database version, and other configurations, and then click Save and Deploy to complete the deployment.
Navigate to the production environment and select New Resource. Choose the MySQL resource type and enter the configuration details.

Repeat step 3 for the DR environment.

Verify that all three environments now have MySQL resources deployed. The Kubernetes connector is used for the local environment, the AWS connector is used for the production environment, and the Alibaba connector is used for the DR environment. This allows for dynamic creation of corresponding resources based on the current environment.

In the Kubernetes cluster, the MySQL container is created for the local environment.

The production environment creates the rds service in the aws.

The dr environment has created the corresponding rds service in the alibaba cloud.

Deploy Application across infrastructure via Walrus File

The Walrus file can be used to deploy an application, in addition to using the UI:

Prepare app.yaml as follows:

  version: v1
  resources:
    - name: mysql
     type: mysql
     attributes:
       architecture: standalone
        database: mydb
       engine_version: "8.0"
       username: rdsuser

Run the command to deploy MySQL to different environments.

  # deploy to local environment
  walrus apply -f app.yaml -p default -e local

  # deploy to production environment
  walrus apply -f app.yaml -p default -e production

  # deploy to dr environment
  walrus apply -f app.yaml -p default -e dr

CLI deployment allows for the reuse of the same Walrus file for multiple environments.

We have simplified application deployment by configuring resource definitions and deploying them to multiple environments, reducing infrastructure complexity and workload for developers and operators.

With XaC (Everything is Code), Walrus unifies the application lifecycle from provisioning underlying infrastructure resources to releasing upper tier applications. It also integrates with CI tools to automate CI/CD pipeline delivery. If you are tired of dealing with complex infrastructure provisioning or want to streamline your application management and deployment process, consider installing and using Walrus.

If you are interested in Walrus, Welcome to our community:

Discord: https://discord.gg/fXZUKK2baF
Twitter/X: https://twitter.com/Seal_io
LinkedIn: https://www.linkedin.com/company/seal-io
Youtube: https://www.youtube.com/@Seal-io

Take 6 Actions to Make Your Platform Engineering Strategies happen!

Seal — Fri, 01 Mar 2024 06:56:13 +0000

SealFollow

Manage GPU clusters for running LLMs

How to Automate CI/CD Pipeline with Walrus and GitLab

Seal — Tue, 27 Feb 2024 16:00:00 +0000

Walrus file is a new feature released in Walrus 0.5. It allows you to describe applications and configure infrastructure resources using a concise YAML. You can then execute walrus apply in the Walrus CLI or import it on the Walrus UI. This will submit the Walrus file to the Walrus server, which will deploy, configure, and manage applications and infrastructure resources. This makes it easy to reuse them across multiple environments.

In this tutorial, we will demonstrate how to integrate Walrus CLI with GitLab CI and release applications via Walrus file to improve CI/CD pipelines.

Prerequisites

Before getting started, please prepare:

Create a new project on GitLab and import our demo project into it. First, ensure that you have the GitHub type Import Project permission enabled. If not, refer to the snapshot below and enable it in the Admin Area.

Alternatively, you can manually git clone the project and push a new GitLab project into it.
Install Walrus via docker run, and expose additional ports 30000~30100 for NodePort of built-in k3s cluster workload, for more information: https://seal-io.github.io/docs/deploy/standalone

sudo docker run -d --privileged --restart=always -p 80:80 -p 443:443 -p 30000-30100:30000-30100 --name walrus sealio/walrus:v0.5.1

3.Access Walrus. In the latest version, Walrus automatically creates a local environment in the default project and adds built-in K3s or other K8s clusters in the Walrus container as a connector in this environment. For demonstration purposes, this example will use the K3s cluster.

4.Create an API key on Walrus to authenticate for communication between the Walrus CLI and Walrus Server in following steps. Here is the guidance:

Navigate to Account>User center>API Keys
Click New Key, name it and set up expiration
After configuring, copy the generated key and save it. If the key is lost in the future, it can be regenerated for replacement.

Configure Walrus CLI and Integrate it with GitLab CI

In this section, we will demonstrate an example from CI to CD. Follow the steps below to integrate Walrus CLI with GitLab CI:

Access GitLab and navigate to Admin Area > Settings > CI/CD > Variables
Add following variables, configure the sensitive information that is required by GitLab CI execution:

CI_REGISTRY_USERNAME: The username of the CI build container image to push to Docker Hub, refer to docker login.
CI_REGISTRY_PASSWORD: The password of the CI build container image to push to Docker Hub, refer to docker login.
CD_WALRUS_SERVER: The URL that Walrus accesses, whose format is https://domain:port.
CD_WALRUS_TOKEN: API Keys of Walrus for authentication.

3.Create .gitlab-ci.yml file in the GitLab project (exists by default in the sample project), which will define your CI/CD workflow. Below is a sample .gitlab-ci.yml file for deploying the sample project Game 2048. You can copy and modify it as needed, such as changing the image sealdemo/game2048 to your own image name.

stages:
  - compile
  - build
  - deploy

variables:
  CI_PROJECT_DIR: ./
  CI_IMAGE_NAME: sealdemo/game2048
  CD_WALRUS_PROJECT: default
  CD_WALRUS_PROJECT_ENV: local

compile:
  stage: compile
  image: maven:3-openjdk-8
  artifacts:
    paths:
      - target/
  script:
    - mvn clean package

build:
  dependencies:
  - compile
  stage: build
  image:
    name: gcr.io/kaniko-project/executor:debug
    entrypoint: [""]
  artifacts:
    paths:
      - target/
  before_script:
    - mkdir -p /kaniko/.docker
    - echo "{\"auths\":{\"https://index.docker.io/v1/\":{\"auth\":\"$(printf "%s:%s" "${CI_REGISTRY_USERNAME}" "${CI_REGISTRY_PASSWORD}" | base64 | tr -d '\n')\"}}}" > /kaniko/.docker/config.json
  script:
    - /kaniko/executor
      --context "${CI_PROJECT_DIR}"
      --dockerfile "${CI_PROJECT_DIR}/Dockerfile"
      --destination "${CI_IMAGE_NAME}:${CI_COMMIT_SHORT_SHA}"

deploy:
  stage: deploy
  image: alpine
  before_script:
    - wget -O walrus --no-check-certificate "${CD_WALRUS_SERVER}/cli?arch=amd64&os=linux"
    - chmod +x ./walrus
  script:
    - ./walrus login --insecure --server ${CD_WALRUS_SERVER} --token ${CD_WALRUS_TOKEN}
    - ./walrus apply -f ./walrus-file.yaml -p ${CD_WALRUS_PROJECT} -e ${CD_WALRUS_PROJECT_ENV}

4.Check out walrus-file.yaml, which Walrus uses to deploy applications (already exists by default in the sample project). Walrus file is a concise YAML structure that describes the application's deployment configuration. You can make any necessary changes to this file:

version: v1
resources:
- name: game2048
  type: containerservice
  attributes:
    containers:
    - profile: run
      image: ${CI_IMAGE_NAME}:${CI_COMMIT_SHORT_SHA}
      ports:
      - schema: http
        external: 8080
        internal: 8080
        protocol: tcp
      resources:
        cpu: 0.25
        memory: 512

5.Access GitLab, navigate to Admin Area > CI/CD > Runners, check that GitLab Runner is online properly(how to install GitLab Runner), which is used to run the CI/CD pipeline defined by .gitlab-ci.yml:

6.Navigate to 2048 Project > Build > Pipelines, select Run pipeline.

Wait for the pipeline to finish running and check the results of the pipeline run:

View the pipeline's running logs:

The logs indicate that the pipeline ran successfully. GitLab CI completed the CI/CD steps of Maven build, container image build upload, and application deployment to the K3s cluster using the Walrus CLI, in that specific order.

7.After successfully running the pipelines, you can visit Walrus to view the deployed game2048 application!

Access the 2048 game by using automatically recognized endpoints and the /2048 path. Here is the full URL: http://domain:port/2048.

Now, we have successfully integrated Walrus CLI with GitLab CI. By using the Walrus file in Walrus 0.5.x, developers can now automate the deployment of applications in a more user-friendly way when committing application code to GitLab.

With XaC (Everything is Code), Walrus can unify and manage the entire application lifecycle, from the provisioning infrastructure resources to releasing the upper tier application. This tutorial only covers one scenario. If you are interested in learning more, you can explore other scenarios with Walrus, such as provisioning Kubernetes clusters, creating cloud RDS databases, and configuring LB policies.

If you are interested in Walrus, Welcome to our community:

Discord: https://discord.gg/fXZUKK2baF
Twitter/X: https://twitter.com/Seal_io
LinkedIn: https://www.linkedin.com/company/seal-io
Youtube: https://www.youtube.com/@Seal-io

If you have any questions about Walrus, please feel free to let me know, I am here to help you :)

Our Talk has been selected for OpenTofu Day on KubeCon

Seal — Mon, 19 Feb 2024 03:17:09 +0000

Join us for an exclusive analysis uncovering where OpenTofu could address needs that Terraform has yet to fulfill, backed by quantitative insights, presented by Lawrence Li. Don't miss this exciting session – Seal you there💡

For more information about this talk, please check out: https://colocatedeventseu2024.sched.com/event/1YFgo/cl-lightning-talk-alias-terraformtofu-jobs-done-now-what-lawrence-li-seal

Seal Launches Walrus 0.5: Revamps Workflow for an Out-of-the-Box Deployment Experience

Seal — Mon, 29 Jan 2024 17:00:00 +0000

Application management platform based on IaC Walrus 0.5 is officially released!

Walrus 0.5 builds upon the new application model introduced in Walrus 0.4.This new model significantly reduces repetitive configuration work and shields development teams from the complexities of cloud-native and infrastructure management.

With Walrus 0.5, the workflow has been revamped, and abstraction capabilities have been enhanced to create an out-of-the-box product experience. This release further optimizes application deployment and delivery through a platform engineering approach.

"Multi-cloud and hybrid cloud have become the mainstream IT infrastructure architecture for enterprises. The complexity of managing heterogeneous infrastructure increases as businesses scale. Nowadays, reducing management costs and enhancing delivery efficiency have become two of the top priorities for enterprises," said George Qin, Co-founder and CEO of Seal. "Walrus is dedicated to simplifying application management using a platform engineering approach, alleviating the cognitive load on development and operations to address the current complex IT challenges."

Refactor Workflow and Enhance Abstraction for Simplified Resource Management

Walrus 0.5 upgrades the UI, optimizing the management interaction for resources and their definitions, providing an intuitive and streamlined management experience.

Services and resources are unified into a single resource view. In this view, various operations for resource details, such as managing resources and underlying components, viewing logs, executing to the terminal for debugging, and getting access URLs for services, are all supported.

By integrating various management functions within a single pane of glass, you no longer need to switch between different windows, enhancing the overall experience and making it easier to handle complex resource management tasks.

Resource Definition is the core of Walrus for building a unified abstraction layer on top of multi-cloud and hybrid infrastructure. Walrus 0.5 further enhances Resource Definitions by:

Enrich built-in resource definitions while optimize the creation of matching rules for resource definitions.
Provide a management view for resource definitions associated with resources, facilitate unified management for operations or architecture teams.
Declare multiple resource definitions of the same type, facilitating flexible rule matching for different teams.

Polymorphic Support from Docker to Kubernetes

Walrus 0.4 introduced the core feature of "configure once, run polymorphically." In Walrus 0.5, we've extended that magic to support both Docker and Kubernetes polymorphically.

This feature allows users to create and execute applications in a Docker environment on their personal computer. The same YAML application definition can be used to deploy the application to both staging and production Kubernetes environments without requiring an understanding of the configuration differences between the two.

Developers can deploy applications locally in Docker using Walrus's built-in resource types, such as containerservice, mysql, postgresql, and redis. The same application definition can be deployed to another environment underlying Kubernetes without any modification. Resource definitions can also be used to extend corresponding resource types.

If you're all about Docker, Walrus 0.5 has your back.

During the Walrus 0.5 installation, container applications can be deployed using Docker alone. To install Walrus in a local Docker environment, developers can use the Walrus CLI command walrus local install in a Docker extension manner. This means that Walrus can run without depending on an external K8s or the built-in K3s.

During the application deployment phase, the new version includes Docker connectors and Docker application templates. These features assist developers in deploying applications to Docker environments.

Further Extending Deployment Flexibility

Add OpenTofu as a Deployer Option

OpenTofu was introduced as an open-source alternative to Terraform due to changes in its license. In Walrus 0.5, formal support for OpenTofu 1.6.0 is provided, replacing the previous manual switch option for Terraform.

Navigate to System Settings > Deployment Management > Basic Settings > Deployer Image, you can switch the default Deployer from Terraform to OpenTofu (image: sealio/opentofu-deployer:v1.6.0-seal.1). This improvement aims to provide more options and avoid vendor lock-in.

Walrus File: Code-Defined Deployment of Resources

The new version of Walrus introduces the Walrus File feature, which is a YAML file used to deploy Walrus resources.

Similar to a Docker Compose file, this file provides a concise definition of application services and infrastructure resources. However, it can be used to create application services and resources for various multi-cloud and hybrid infrastructures, not limited to Docker or Kubernetes.

The Walrus CLI walrus apply/delete -f allows you to apply or delete Walrus resources described in the Walrus File. You can also integrate the Walrus File with existing CI/CD tools and processes using the Walrus CLI, making Walrus more flexible to meet various deployment requirements.

To make learning easier, we recommend using the Walrus File Hub as a reference. You can find relevant YAML examples at https://github.com/seal-io/walrus-file-hub.

100% Open Source, Easy to Get Started

We're true to the open-source spirit! Walrus is fully open source based on the Apache 2.0 license, and you can deploy it on a computer with Docker installed with just one command.

sudo docker run -d --privileged --restart=always -p 80:80 -p 443:443 -p 30000-30100:30000-30100 --name walrus sealio/walrus:v0.5.0

Check us out on Github and give us a star if you dig what we're doing!

Cheers to simplified app management with Walrus 0.5!