keshan / gocker

This project is an educational initiative to learn Go by developing a Docker-like container system from scratch.

Gocker - A Docker-like Container System in Go

Welcome to Gocker! This project is an educational initiative to learn Go by developing a Docker-like container system from scratch. By building this project, we aim to cover all the features and concepts of the Go programming language, as well as delve into production-grade tools and design patterns.

Table of Contents

• Gocker - A Docker-like Container System in Go
  • Table of Contents
  • Introduction
  • Features
  • Installation
  • Usage
    • Creating a Container
    • Starting a Container
    • Stopping a Container
    • Removing a Container
    • Listing Containers
    • Building an Image
    • Listing Images
    • Removing Images
    • Development Steps
    • Architecture
    • Contributing
    • License

Introduction

Gocker is a lightweight container system inspired by Docker. It aims to provide a simplified version of containerization functionalities, allowing users to create, manage, and run containers. This project is designed for learning purposes and is not intended for production use.

Features

• Basic Container Creation: Create and manage containers.
• Resource Isolation: CPU and memory limits for containers.
• Networking: Basic networking capabilities for containers.
• Image Management: Build, list, and remove container images.
• Container Lifecycle Management: Start, stop, and remove containers.
• Simple Orchestration: Manage multiple containers and their interactions.

Installation

To get started with Gocker, follow these steps:

1. Clone the repository:

   git clone https://github.com/keshan/gocker.git
   cd gocker

2. Build the project:

   go build -o gocker

3. Run Gocker:

   ./gocker

Usage

Creating a Container

./gocker create -name mycontainer -image myimage

Starting a Container

./gocker start mycontainer

Stopping a Container

./gocker stop mycontainer

Removing a Container

./gocker rm mycontainer

Listing Containers

./gocker ps

Building an Image

./gocker build -t myimage .

Listing Images

./gocker images

Removing Images

./gocker rmi myimage

Development Steps

• Basic Container Creation
• Resource Isolation
• Networking
• Image Management
• Container Lifecycle Management
• Simple Orchestration

Architecture

Gocker is structured to mirror the architecture of Docker, albeit in a simplified form. The core components include:

• CLI: Command-line interface for interacting with Gocker.
• Container: Manages the lifecycle of containers.
• Image: Handles the creation and management of container images.
• Network: Provides basic networking functionalities for containers.
• Volume: Manages data volumes for persistent storage.
• Runtime: Core logic for running containers with resource isolation.
• Logging: Captures and manages logs from containers.

Contributing

We welcome contributions from the community! To contribute to Gocker, please follow these steps:

1. Fork the repository.
2. Create a new branch for your feature or bugfix.
3. Make your changes and commit them with descriptive messages.
4. Push your changes to your forked repository.
5. Create a pull request to the main repository.

License

This project is licensed under the MIT License. See the LICENSE file for details.