Merge pull request #39 from FL303/main

Added and updated profiles

content/ecosystem/build-vs-buy/build-it-yourself/_index.md

@@ -19,6 +19,8 @@ There are a number of tools teams are using when building their own Internal Dev
 [Helm]({{< relref "helm" >}}) | The package manager for Kubernetes
 [Jenkins]({{< relref "jenkins" >}}) | Build great things at any scale
 [Portainer CE]({{< relref "portainer-ce" >}}) | Self-service containers on Kubernetes.
+[Kubevela]({{< relref "kubevela" >}}) | Make shipping applications more enjoyable
+[Portainer CE]({{< relref "portainer-ce" >}}) | Self-service containers on Kubernetes.
 [Pulumi]({{< relref "pulumi" >}}) | Modern Infrastructure as Code
 [Terraform]({{< relref "terraform-by-hashicorp" >}}) | Write, Plan, Apply
 

content/ecosystem/build-vs-buy/build-it-yourself/argo-cd.md

@@ -5,8 +5,52 @@ url="/diy/argo-cd"
 
 # Argo CD
 
-Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. It follows the GitOps pattern of using Git repositories as the source of truth. You can define Kubernetes manifests in several different ways.
+**Claim:** Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes.
+
+
+**Focus:** Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. It follows the GitOps pattern of using Git repositories as the source of truth. You can define Kubernetes manifests in several different ways.
+
+Website & docs: https://argo-cd.readthedocs.io/en/stable/
 
 {{< button href="https://argoproj.github.io/argo-cd/" target="_blank" >}}
 -> Argco CD
 {{< /button >}}
+
+## What is ArgoCD? ##
+ArgoCD is a tool that offers continuous delivery of any Kubernetes resource, including Argo events, services, and deployments across multiple Kubernetes clusters.
+Kubernetes manifests can be specified in multiple ways, including kustomize applications, helm charts, ksonnet applications, jsonnet files, plain directory of YAML/json manifests, and any custom config management tool configured as a config management plugin.
+The application’s UI enables users to see the status of deployments and monitor projects and user access. The GitOps tool is self-hosted and is open source on GitHub. It follows the GitOps pattern for defining the desired application state by using Git repositories as the source of truth. ArgoCD’s features include several synchronization options, user access controls, and status checks. 
+ArgoCD regulates application states by automating deployment to ensure applications are in the specified target environments. These deployments can monitor updates to branches, tags, or pinned to a specific version of manifests.
+However, using ArgoCD as a component for an IDP can be difficult because the tool is hard to debug and sometimes unreliable. Teams handling ArgoCD need extensive experience in Kubernetes and deployment systems with every single developer. Making changes to the environment structure, such as adding a service or resource dependencies, often requires the developer to rework the entire system.
+## What is the mission and vision of ArgoCD? ##
+Intuit, which acquired Applatix in 2018, began developing ArgoCD to “address the need for a fast, reliable continuous delivery service for deploying hundreds of microservices across a fleet of Kubernetes clusters.” 
+The system aims to bring users closer to constant monitoring, analytics, and automated remediation of operational problems. ArgoCD provides continuous operations through declarative specifications, automated learning, and automated categorization of system behavior.
+ArgoCD supports both the push and pull-based GitOps models, making it malleable for developers partial to either style. The system constantly monitors running applications and checks their state in real-time, then compares it to the target state denoted in the Git repo.
+Intuit wanted a continuous delivery system but couldn’t find a current product on the market that fit all of their needs. Their ideal system would:
+- Be Kubernetes-native
+- Be declarative 
+- Be compatible with all Kubernetes manifests, including YAMLs, ksonnet/jsonnet, Helm, and kustomize
+- Use Git as the source of truth
+- Provide clear separation between continuous integration/delivery (CI/Cd) and continuous deployment (CD) processes
+- Be enterprise-friendly through auditability, compliance, security, RBAC, and SSO
+
+Since they couldn’t find a program that checked all of their boxes, Intuit developed ArgoCD to detect and remediate any deviations from the controlled configuration immediately.
+
+## Core features of ArgoCD ##
+
+- Multi-Tenancy – ArgoCD can effectively monitor numerous applications of different teams through Projects. 
+- Multi-Cluster – ArgoCD can sync all applications on its Kubernetes cluster and manage external clusters.
+- Configuration Drift Detection – Solves the problem that often occurs in GitOps by bringing back Kubernetes resources that drift away from the configuration stored in the Git.
+- Garbage Collection – Solves the GitOps problem of frequent inability to delete resources by automatically removing unnecessary resources while syncing.
+- Auto Deployment – ArgoCD automatically deploys applications to specified target environments.
+- SSO Integration – Integrates with multiple SSO platforms like OIDC, OAuth2, LDAP, SAML 2.0, GitHub, GitLab, Microsoft, and LinkedIn
+- Rollback and Roll-Anywhere – can rollback or roll to any app configuration in the Git repository 
+Complex Application Rollouts – makes complicated rollouts simple with PreSync, Sync, and PostSync hooks
+- Webhook integration – Integrates with Webhook methods including GitHub, BitBucket, and GitLab
+- Real-Time Web UI – user interface enables real-time monitoring of application activity
+- Audit Trails – creates a map for application events and API calls in case of auditing
+- Access Tokens – uses application tokens for automation
+- Flexible Use – can be used as a standalone system or in conjunction with other pipeline tools like Argo Workflow or Jenkins.
+
+ArgoCD is a CD system for seasoned Kubernetes and DevOps experts looking for an automated and auditable application deployment and lifecycle management.
+

content/ecosystem/build-vs-buy/build-it-yourself/flux-cd.md

@@ -5,8 +5,91 @@ url="/diy/flux-cd"
 
 # Flux CD
 
-Flux is a tool for keeping Kubernetes clusters in sync with sources of configuration (like Git repositories), and automating updates to configuration when there is new code to deploy.
+**Claim:** Flux is a set of continuous and progressive delivery solutions for Kubernetes, and they are open and extensible.
+
+**Focus:** Flux CD is a Continuous Delivery tool to help keep Kubernetes clusters in sync with configuration sources such as Git repositories and automate configuration updates when available. Flux is built with the GitOps toolkit and supports multi-tenancy and syncing an arbitrary number of Git repositories. Flux CD is one of the multiple components available to developers looking to utilize open source tools to build an IDP. It is most often compared to ArgoCD.
+
+Website: <https://fluxcd.io/>
+
+Docs: <https://fluxcd.io/docs/>
 
 {{< button href="https://fluxcd.io/" target="_blank" >}}
 -> Flux CD
 {{< /button >}}
+
+What is FluxCD?
+---------------
+Flux CD is a GitOps operator for Kubernetes that works by synchronizing the state of manifests in a Git repository to the designated setting for a cluster. Users who have experimented with various CD systems claim that Flux offers the simplest interface to use and set up a GitOps workflow.
+
+The tool focuses on specific clusters and monitors a remote Git repository to adjust any changes in Kubernetes manifests. While this may seem like a tool with limited capabilities, seasoned developers can use multiple instances of Flux CD to create intricate scenarios, with each instance having specific RBAC permissions.
+
+### What Is the Mission and Vision of Flux CD? ###
+
+The creators of Flux designed the system for
+
+-   Cluster Operators who automate the provision and configuration of clusters
+
+-   Platform Engineers who build CD systems for developer teams
+
+-   App Developers who rely on CD to get their code up and running
+
+However, Flux openly concedes that platform developers who want to create their own CD system should use the GitOps Toolkit because it offers requirements not included with Flux.
+
+### A Brief History of Flux CD ###
+
+Flux CD was initially created by Weaveworks and has since become a Cloud Native Computing Foundation (CNCF) project with an Apache 2.0 license on GitHub.
+
+### Core Features of Flux CD ###
+
+-   Operates in true GitOps fashion by periodically pulling a remote Git repository and applying its manifest files to the cluster if there are any new changes
+
+-   Offers source configuration from Git and Helm repositories
+
+-   Provides support for Kustomize and Helm
+
+-   Integrates with Kubernetes RBAC
+
+-   Triggered by events and provides periodic reconciliation
+
+-   Monitors the health of clusters and workloads
+
+-   Manages the dependency of infrastructure and workloads
+
+-   Alerts webhook senders to external systems
+
+-   Handles external events for webhook receivers
+
+-   Provides policy-driven validation for OPA, Kyverno, and admission controllers
+
+-   Offers seamless integration with Git providers, including GitHub, GitLab, and Bitbucket
+
+-   Requires little management after installation, and changes can be implemented by reapplying the same manifests with new values, using Kustomize, or using Helm
+
+-   Easy to troubleshoot repository issues because it's a highly specific system
+
+Other important things to note include:
+
+-   Flux is a simple component and doesn't have a multi-tenancy mode
+
+-   Flux can be used in a multi-cluster scenario
+
+-   Developers can enable auto-deploy new versions of container images 
+
+-   Flux can reapply drifted resources through the synchronization of workload states
+
+-   Flux can delete unnecessary resources from the cluster
+
+-   Flux doesn't work with Cluster API (CAPI) providers or workflow providers like GitHub Actions, Tekton, and Argo.
+
+## Flux CD vs ArgoCD ##
+
+When addressing Flux CD, we'd be remiss if we didn't touch on the similarities and differences between this system and ArgoCD. Many developers have their preference for which tool to use for implementing a GitOps style of application deployments, and it's helpful to understand which system will work best for specific projects.
+
+|- | Flux CD | ArgoCD |
+| -- | --- | --- |
+| Repositories | Allows one repository connection per instance | Can connect multiple Git repositories to one cluster |
+| Clusters | Only works inside a cluster in typical Kubernetes Operator fashion | Can manage multiple clusters in one instance |
+| Graphical User Interface (GUI) | Doesn't provide a GUI but can be integrated with Weaveworks SaaS services | GUI visualizes relationships between objects in the app manifests and monitors apps |
+| Enterprise Readiness | Limited to Kubernetes RBAC | Features SSO and built-in support for RBAC |
+| Manifest Generation | Has some ways to enable manifest generation | Has built-in support for more tools, including Kustomize, Helm, and Ksonnet |
+| Updating Container Images | Can update container images automatically | Container image versions can only be updated with a commit to the change in the Git repo |

content/ecosystem/build-vs-buy/build-it-yourself/kubevela.md

@@ -0,0 +1,61 @@
++++
+title="Kubevela"
+url="/diy/kubevela"
++++
+
+# Kubevela
+
+**Claim:** Make shipping applications more enjoyable.
+
+**Focus:** KubeVela introduced the open application model - programmatically describing the state of an application by encompassing the application configuration and the infrastructure configuration in a higher-level API. This approach keeps the environment specific elements of configurations (for example specific dependencies and resources) separated from the environment agnostic elements (such as the general architecture of workloads). Shifting to the open application model makes it necessary to restructure the entire config setup. Kubevela can be used as one of many components to orchestrate deployments.
+
+Website: https://kubevela.io/
+
+Docs: https://kubevela.io/docs/
+
+{{< button href="https://kubevela.io/" target="_blank" >}}
+-> Kubevela
+{{< /button >}}
+
+What is KubeVela?
+-----------------
+KubeVela's goal is to make shipping applications more enjoyable. As a modern application delivery platform, KubeVela works to make application deployment and operation across hybrid, multi-cloud environments faster, easier, and more reliable.
+
+The system is infrastructure agnostic, programmable, and application-centric. Ideally, the platform effortlessly scales and adapts to platform needs. KubeVela offers potential for multiple users, including app developers, operators, and DevOps engineers; platform builders for PaaS, Serverless, and app management or delivery systems; and ISV, SaaS owners, and app architects.
+
+Developers design deployment topology, policy, and workflow through their Open Application Model (OAM), then use KubeVela to distribute components to the target cloud, IoT or Edge device, or Kubernetes cluster.
+
+What KubeVela Is NOT
+--------------------
+
+-   A CI/CD System: KubeVela works downstream of a CI process as a Continuous Delivery (CD) control plane. With KubeVela, developers retain their adopted CI process.
+
+-   Platform as a Service (PaaS): KubeVela claims to be more flexible and programmable than a PaaS system.
+
+-   A Serverless Platform: KubeVela isn't hard-coded like serverless platforms (including AWS Lambda) but can deploy both Kubernetes-based serverless workloads and cloud-based functions.
+
+-   A Platform Agnostic Developer Tool: Developers can integrate KubeVela with developer-facing tools like Waypoint. In these cases, KubeVela serves as the underlying deployment platform
+
+-   Helm: Helm works as a package manager for Kubernetes, and developers can use KubeVela to deploy Helm charts.
+
+What Is the Mission and Vision of KubeVela?
+-----------
+
+Although Kubernetes has become the standard layer for abstracting away low-level infrastructure details, it doesn't offer abstractions to model application deployment in addition to hybrid and distributed environments. In response to this gap impacting user experience, KubeVela developed the system to reduce unexpected errors caused by misconfigurations in production.
+
+Additionally, a system layer was needed to address the issues surrounding fragmented microservice application deployment and outgrown system capabilities as developers scaled their platform.
+
+KubeVela was designed to be an effective solution to these problems. KubeVela's keyword is "simplicity," considering that it tries to take a complicated system and make it easier for developers of all skill levels to use.
+
+KubeVela is a Cloud Native Computing Foundation (CNCF) sandbox project.
+
+Core Features of KubeVela
+-----------
+
+KubeVela offers multiple features as a way to simplify Kubernetes use for developers.
+
+-   Application Centricity: KubeVela provides a consistent and higher-level API to capture and execute full microservice deployments on hybrid environments through an Open Application Model (OAM). By keeping applications at the heart of the system, users can declare placement strategy, traffic sharing, and rolling updates at the application level. According to KubeVela creators, this results in no infrastructure-level concerns and simple deployment.
+
+-   Programmable Workflow: KubeVela uses a Directed Acyclic Graph (DAB) to model application delivery and expresses app delivery through a modern data configuration language (CUE). This enables developers to create application deployments based on platform needs without restrictions.
+
+- Infrastructure Agnostic: As an application delivery control plane, KubeVela operates fully decoupled from runtime infrastructure. Following the workflow designed by the developer, the system deploys workload types, including containers, cloud services, databases, or VM instances to clouds or Kubernetes clusters.

content/ecosystem/build-vs-buy/frameworks/_index.md

@@ -18,3 +18,4 @@ Using frameworks is the quickest and most state-of-the-art way to build your Int
 [Gimlet]({{< relref "gimlet" >}}) | A modular workflow for Kubernetes
 [Upbound]({{< relref "upbound" >}}) | Universal cloud APIs and consoles for your team
 [DevOpsBox]({{< relref "devopsbox" >}}) | The first full cloud-native NoOps platform
+[Shipa]({{< relref "shipa" >}}) | Application As Code (AaC)