Kubernetes vs. CloudFoundry

Question

The next version of CloudFoundry / Diego will offer built-in support for Docker containers that will be hosted on multiple hosts [ link ]. It sounds a lot like Kubernetes.

Of course, the problem Kubernetes is trying to solve is more general, where CloudFoundry is more focused on application development. However, for me it sounds like both are moving in the same direction, and CloudFoundry adds a lot more features on top of simple orchestration.

So I'm wondering in which cases using Kubernetes will do more good than CloudFoundry?

Answer 1

Like CloudFoundry (past) and Kubernetes (real) committers, I'm probably uniquely qualified to answer this question.

PaaS-like

I like to call CloudFoundry "Application PaaS" and Kubernetes "Container PaaS", but the difference is pretty subtle and fluid, given that both projects change over time to compete in the same markets.

The difference between the two is that CF has an intermediate layer that accepts a (12-factor) user application (e.g. jar or gem) and Heroku-style buildpack (e.g. Java + Tomcat or Ruby) and creates a drop (similar to the Docker image) . CF does not provide the user with a containerization interface, but Kubernetes does.

The audience

CloudFoundry's primary audience is enterprise application developers who want to deploy stateless 12-factor applications using Heroku-style builds.

The Kubernetes audience is a bit wider, including both stateless application developers and stateful developers who provide their own containers.

This difference may change in the future:

• CloudFoundry can start accepting docker images ( Lattice accepts Docker images ).
• Kubernetes can add an image generation layer ( OpenShift does something like this ).

Feature Comparison

As both projects mature and compete, their similarities and differences will change. So compare with a dash of salt.

Both CF and K8s have many similar features, such as containerization, namespace, authentication,

Competitive advantages of Kubernete:

• Group and scale container containers that share a network stack, and not just scale independently.
• Bring your container
• Sustainability
• A more active, more active OSS community
• More extensible architecture with replaceable components and third-party plugins
• Free web interface

Cloud competitive advantages:

• Mature authentication, user grouping and multi-tenant support [x]
• Bring your own app.
• Enabled load balancer
• Deployed, scaled and supported by BOSH [x]
• Reliable record and aggregation of indicators [x]
• Enterprise Web Interface [x]

[x] These functions are not part of Diego or are included in the Grill.

Deployment

One of CloudFoundry’s competitive advantages is its mature BOSH deployment mechanism, which allows you to use features such as scaling, resurrection and monitoring of the main components of CF. BOSH also supports many levels of IaaS with an abstraction of a pluggable cloud provider. Unfortunately, the BOSH learning curve and deployment configuration management are nightmares. (As a BOSH battalion commander, I think I can say it with accuracy.)

Kubernetes deployment abstraction is still in its infancy. Many target environments are available mainly in the repo, but not all of them work, are well tested or supported by the main developers. This is mainly maturity. It can be expected that this will improve over time and increase abstraction. For example, Kubernetes in DCOS allows you to deploy Kubernetes in an existing DCOS cluster with a single command.

Historical context

Diego is a reissue of the agent of the execution of drops CF. It was originally developed before Kubernetes was announced and gained more features as the competitive landscape developed. Its initial goal was to generate drops (user application + CF buildpack) and run them in Warden (renamed to Garden when rewriting in Go) containers. Since its inception, it has also been repackaged as Lattice , which is somewhat like CloudFoundry-lite (although this name was adopted by an existing project ). For this reason, Lattice is like a toy, because it deliberately reduces the audience of users and the scope, clearly misses the functions that will make it "ready to go." Features that CF already provides. This is partly due to the fact that Lattice is used to test the main components without any overhead from the more complex CF, but you can also use Lattice in internal environments with a high level of trust, where security and multi-tenant are not so important.

It is also worth mentioning that CloudFoundry and Warden (its container engine) preceded Docker, and a couple of years later.

Kubernetes, on the other hand, is a relatively new project that Google developed over the years using containers with BORG and Omega. Kubernetes could be thought of as 3rd generation orchestration on Google, just like Diego 3rd generation container orchestration in Pivotal / VMware (v1 written in VMware v2 in VMware using Pivotal Labs, v3 in Pivotal after he took over the project).

Answer 2

Cloud Foundry is a great tool assuming you are always ready to work within the limits of the offer, as it is very stubborn / prescribed. The web interface is convenient for viewing on the first day, but is rarely used after you start working with the client and configure the CI / CD pipeline. I found that Cloud Foundry works fine until pop-ups appear that are not fully supported in Cloud Foundry. Providing these use cases may delay projects trying to solve these problems, as a result of which you lose the visibility of the infrastructure and maintain the benefits of those components that mainly work outside of Cloud Foundry (I think that several databases, kafka, hadoop, cassandra, etc. .d.). Over time, I suspect that the Docker-related momentum and Cloud Foundry's inflexibility will lead users to Kubernetes, Mesos, or Docker Swarm / Datacenter. Cloud Foundry may be able to catch up with these three, but this is unlikely to be related to the popularity of these open source projects.

Answer 3

It is difficult to answer why the company will build a product that is essentially similar to another product. There are many reasons. Perhaps they have already started using it and invested in it. Maybe they (CF) think Kubernetes is done poorly or displays API / model / details incorrectly. Perhaps they think they can move faster if they control the entire product, rather than invest.

Of course, I say this as a Kubernetes developer - you can ask the same questions from Coubernes vs Mesos, Amazon ECS vs Kubernetes, or Docker Swarm vs Kubernetes.

I hope that over time we will all move in the same direction and can cooperate more and spend less time on a new creation.

For Kubernetes, the focus is on application developers: simple and powerful primitives that let you quickly create and deploy applications on a scale. We rely on our experience (well, Google) with similar technologies to chart our course. Other people will have different impressions or opinions.

Answer 4

A significant difference, in my opinion, is the approach they use:

CF automatically creates a runtime of 3 components: the application binary file provided by the user, the assembly package containing the middleware needed to run the application, and the OS image (stemcell). The CF user (developer) must provide only the application binary (for example, the JAR executable). CF takes care of the rest, i.e. packaging and launching the application.

Kubernetes expects the developer of Docker images that contain middleware and OSs that are already embedded and ready to run. To do this, the Kubernetes “deployment manifest” (for example, the Helm diagram) describes not only one application or service, but all of the [micro] services that make up your decision at runtime. You submit one declarative description of your runtime, and Kubernetes makes sure that the actual state of the runtime matches the description you provide.

Thus, the CF approach allows him to solve such use cases as "replace the OS with a fixed security flaw in the entire cloud without downtime for your services." But it also focuses on deploying a service to a service instead of a declarative description of the target "ideal" runtime of your system.

Answer 5

Cloud Foundry is an open source cloud computing system. Cloud Foundry allows you to deploy projects in different spaces, and also associates any cloud service with your application.

Kubernete is more like a container decorating tool that automates the deployment, scaling, and management of containerized applications. It uses the term pods to define a container or group of containers.

Any deployment of kubernetes requires at least two resources:

1) deploy.yaml: this resource determines which version of the image to select from the container registry, replica sets (pod replicas), deployment, scaling strategies, probes, etc.

2) service.yaml: this is the interface between your internal modules and the outside world, all external traffic will listen on the port defined in this resource, from where it distributes the load on the internal modules.

Another resource is the input provided by kubernetes, which controls the external access to services in a cluster, usually http. Through Ingress, you can provide load balancing, SSL termination, and name-based virtual hosting.

You can find more about kubernetes below: https://kubernetes.io/docs/

Answer 6

[pcf vs kubernetes] [1] The difference between pcf and kubernetes

PCF 

(application-level platform abstraction) • Pivotal Cloud Foundry is a high-level abstraction of cloud-based application development.

• We have an abstraction of the platform at the application level, the creation and deployment of a fully customized application.

• PCF is one example of a PaaS “application” (also called Cloud Foundry application runtime)

• The developer supports the application in the future

• Ideal for new cloud applications. For teams with short life cycles and frequent releases, PCF offers a great product.

  Kubernetes 

(abstraction of the platform at the container level) • Kubernetes is a container planner or orchestrator.

• We have an abstraction of the platform at the container level, the assembly and deployment of containers as part of a complete application.

• Kubernetes is a "containerized" PaaS (sometimes called CaaS).

• Using container management tools, the developer creates and then supports the container in the future.

• For a new application, more work for your engineering team and reduced productivity

Answer 7

KUBERNETES ENGINE

Kubernetes Engine is a managed, ready-to-use environment for deploying containerized applications. It brings our latest innovations to developer productivity, resource efficiency, automation of operations, and open source flexibility to accelerate your time to market.

Launched in 2015, the Kubernetes Engine draws on Google’s experience with services such as Gmail and YouTube in containers for over 12 years. The Kubernetes Engine lets you get started quickly with Kubernetes, eliminating the need to install, manage, and operate your own Kubernetes clusters.

The Kubernetes Engine enables rapid application development and iteration, making it easy to deploy, upgrade, and manage your applications and services. Kubernetes Engine is not just for stateless applications; You can mount persistent storage and even run the database in your cluster. Simply describe the compute, memory, and storage resources needed for application containers, and the Kubernetes Engine will provide and automatically manage the underlying cloud resources. Support for hardware accelerators simplifies the launch of machine learning, general-purpose GPUs, high-performance computing, and other workloads that use specialized hardware accelerators.

Manage your environment with the integrated Kubernetes Engine control panel in the Google Cloud console. Use regular health checks to detect and replace hung or failed applications within your deployments. Container replication strategies, monitoring, and automatic remediation help ensure that your services are highly available and keep your users up and running. Google Site Reliability Engineers (SRE) constantly monitors your cluster and its computing resources, network and storage resources, so you don’t have to do this, giving you time to focus on your applications.

Move from one machine to thousands: Kubernetes Engine auto-scaling allows you to cope with the increased user demand for your services, ensuring their availability when it matters most. Then zoom out during periods of inactivity to save money, or schedule low priority batch jobs to use free cycles. Kubernetes Engine helps you make the most out of your resource pool.

Connect and isolate clusters no matter where you are with detailed network policies using the Global Virtual Private Cloud (VPC) in Google Cloud. Use public services behind one global arbitrary IP address for smooth load balancing. Protection against DOS and other types of edge attacks on your containers.

The Kubernetes Engine uses certified Kubernetes, providing portability across the cloud and LANs. There is no vendor binding: you can extract your applications from the Kubernetes Engine and run them wherever Kubernetes is supported, including on your own local servers. You can adapt integrations like monitoring, logging, and CI / CD using the Google Cloud Platform (GCP) and third-party ecosystem solutions.

CLOUD FONDRY

Cloud Foundry has a container architecture that runs applications in any programming language. Deploy CF applications using existing tools and without changing the code. Create, deploy, and manage high availability Kubernetes clusters with CF BOSH in any cloud.

Applications deployed on Cloud Foundry access external resources through the Open Service Broker API. See available services and integrations in The Foundry.

Cloud Foundry is highly adaptable and will be able to withstand changes in technology, so you can introduce new tools, languages ​​or platforms in the future.

By disconnecting applications from the infrastructure, you can make individual decisions about where to place workloads — indoors, in public clouds, or in managed infrastructures — and move these workloads as needed in minutes, without changing the application.

Cloud Foundry will not disrupt your current workflow. It is compatible with the technologies and tools that you use today - be it AWS, Docker, Kubernetes, Java or .NET - and with virtually any in your current environment.

Cloud Foundry is an open source project, an open contribution and open management model that gives users maximum flexibility to avoid blocking vendors. We help to observe a trustworthy community of diverse minds who come together to solve all kinds of problems. More perspectives and divergent thinking mean stronger code.

Answer 8

After 4 years, the trends look like this:

Kubernetes clusters are getting really cheap these days, and the Kubernetes environment is better.

In addition, most of the competitive opportunities listed by other authors, these days it is very easy to copy inside the tunnels.