This is the source repository for the next version of OpenShift - the third architectural revision. It is based around Docker containers and images and the Kubernetes container management solution. OpenShift adds developer centric and organization centric workflows on top of Kubernetes, and much of the core functionality of OpenShift is designed as plugins to the core Kubernetes concepts.

Please see the OpenShift 3 Project Enhancement Proposal (PEP) for a deeper discussion of the features you see here.

NOTE: This is a very early prototype, and as such is designed for rapid iteration around core concepts.

You'll need Docker and the Go language compilation tools installed.

1. Install Docker and add your user to the 'docker' group

   $ sudo usermod -G docker -a `whoami`
   $ newgrp docker
   

   After doing this, confirm you can list docker processes as your user:

   $ docker ps
   

2. Install the Go language toolkit and set your GOPATH

3. Clone this git repository through the Go tools:

   $ go get github.com/openshift/origin
   $ cd $GOPATH/src/github.com/openshift/origin
   

4. Run a build

   $ go get github.com/coreos/etcd
   $ hack/build-go.sh
   

5. Start an OpenShift all-in-one server (includes everything you need to try OpenShift)

   $ output/go/bin/openshift start
   

6. In another terminal window, switch to the directory:

   $ cd $GOPATH/src/github.com/openshift/origin
   $ output/go/bin/openshift kube create pods -c examples/hello-openshift/hello-pod.json
   

   You can also try the multiple container pod example that includes a database and an admin front-end.

Coming soon: Vagrant environments supporting OpenShift - see Kubernetes README.md for now.

The OpenShift APIs are exposed at http://localhost:8081/osapi/v1beta1/*.

• http://localhost:8081/osapi/v1beta1/services (placeholder)

The Kubernetes APIs are exposed at http://localhost:8080/api/v1beta1/*:

• http://localhost:8080/api/v1beta1/pods
• http://localhost:8080/api/v1beta1/services
• http://localhost:8080/api/v1beta1/replicationControllers
• http://localhost:8080/api/v1beta1/operations

Several experimental API objects are being prototyped upstream, and are included here for integration testing:

• http://localhost:8080/api/v1beta1/images
• http://localhost:8080/api/v1beta1/imagesByRepository
• http://localhost:8080/api/v1beta1/imageRepositories
• http://localhost:8080/api/v1beta1/builds
• http://localhost:8080/api/v1beta1/buildConfigs

A draft of the proposed API is available in this repository. Expect significant changes.

1. How does OpenShift relate to Kubernetes?

   OpenShift embeds Kubernetes and adds additional functionality to offer a simple, powerful, and easy-to-approach developer and operator experience for building applications in containers. Kubernetes today is focused around composing containerized applications - OpenShift adds building images, managing them, and integrating them into deployment flows. Our goal is to do most of that work upstream, with integration and final packaging occuring in OpenShift. As we iterate through the next few months, you'll see this repository focus more on integration and plugins, with more and more features becoming part of Kubernetes.

   OpenShift tracks the Kubernetes upstream at github.com/openshift/kubernetes. See the wiki in that project for more on how we manage the process of integrating prototyped features.

2. What about geard?

   Geard started as a prototype vehicle for the next generation of the OpenShift node - as an orchestration endpoint, to offer integration with systemd, and to prototype network abstraction, routing, SSH access to containers, and Git hosting. Its intended goal is to provide a simple way of reliably managing containers at scale, and to offer administrators tools for easily composing those applications (gear deploy).

   With the introduction of Kubernetes, the Kubelet, and the pull model it leverages from etcd, we believe we can implement the pull-orchestration model described in orchestrating geard, especially now that we have a path to properly limit host compromises from affecting the cluster. The pull-model has many advantages for end clients, not least of which that they are guaranteed to eventually converge to the correct state of the server. We expect that the use cases the geard endpoint offered will be merged into the Kubelet for consumption by admins.

   systemd and Docker integration offers efficient and clean process management and secure logging aggregation with the system. We plan on introducing those capabilities into Kubernetes over time, especially as we work with the Docker upstream to limit the impact of the Docker daemon's parent child process relationship with containers, where death of the Docker daemon terminates the containers under it

   Network links and their ability to simplify how software connects to other containers is planned for Docker links v2 and is a capability we believe will be important in Kubernetes as well (see issue 494 for more details).

   The geard deployment descriptor describes containers and their relationships and will be mapped to deployment on top of Kubernetes. The geard commandline itself will likely be merged directly into the openshift command for all-in-one management of a cluster.

Contributions are welcome - a more formal process is coming soon. In the meantime, open issues as necessary, ask questions on the OpenShift IRC channel (#openshift-dev on freenode), or get involved in the Kubernetes project.

OpenShift is licensed under the Apache License, Version 2.0.