doc(technical-documentation): Added the rest of technical documentation, WiP

docs/technical-documentation/decisions/0001-pipeline-tools.md

@@ -0,0 +1,126 @@
+# CI/CD pipeline tools for composable pipeline
+
+## Context and Problem Statement
+
+In order to build a composable pipeline that provides a golden path and reusable components, we need to define the tools that will be used to execute the pipeline.
+
+ArgoCD is considered set in stone as the tool to manage the deployment of applications. However, the tools to compose and execute the pipeline are still up for debate.
+
+> Note: The pipeline will use many other tools to perform certain actions such as testing, building, and deploying. This ADR is focused on the tools that will be used to compose and execute the pipeline itself.
+
+In general, there are 2 decisions to make:
+
+- What tools should we use to execute the pipeline?
+- What tools should we use to compose the pipeline?
+
+The following use-cases should be considered for this decision:
+
+- **User who wants to manage their own runners (???)**
+- User who only wants to use our golden path
+- User who wants to use our golden path and add custom actions
+- User who wants to use their own templates and import some of our actions
+- User who wants to import an existing GitHub repository with a pipeline
+
+## Considered Options
+
+- Argo Workflows + Events
+- Argo Workflows + Events + Additional Composition tool
+- Forgejo Actions
+- Forgejo Actions + Additional Composition tool
+- Dagger (as Engine)
+- Shuttle (as Engine)
+
+## Decision Outcome
+
+TBD
+
+## Pros and Cons of the Options
+
+### Argo Workflows + Events
+
+**Pro**
+
+- integration with ArgoCD
+- ability to trigger additional workflows based on events.
+- level of maturity and community support.
+
+**Con**
+
+- Ability to self-host runners?
+- way how composition for pipelines works (based on Kubernetes CRDs)
+  - Templates must be available in the cluster where the pipelines are executed, so any imported templates must be applied into the cluster before the pipeline can be executed and cannot simply reference a repository
+  - This makes it difficult to import existing templates from other repositories when using self-hosted runners
+  - This also makes it difficult to use our golden path, or at least we will need to provide a way to import our golden path into the cluster
+  - This also makes the split of every component has its own repo very difficult
+- additional UI to manage the pipeline
+- Additional complexity
+
+### Argo Workflows + Events + Additional Composition tool
+
+**Pro**
+
+- Composability can be offloaded to another tool
+
+**Con**
+
+- All cons of the previous option (except composability)
+- Additional complexity by adding another tool
+
+### Forgejo Actions
+
+**Pro**
+
+- tight integration with GitHub Actions providing a familiar interface for developers and a vast catalog of actions to choose from
+- ability to compose pipelines without relying on another tool
+- Self-hosting of runners possible
+- every component can have its own repository and use different tools (e.g. written in go, bash, python etc.)
+
+**Con**
+
+- level of maturity - will require additional investments to provide a production-grade system
+
+### Forgejo Actions + Additional Tool
+
+**Pro**
+
+- may be possible to use GitHub actions alongside another tool
+
+**Con**
+
+- additional complexity by adding another tool
+
+### Shuttle
+
+**Pro**
+
+- Possibility to clearly define interfaces for pipeline steps
+- Relatively simple
+
+**Con**
+
+- basically backed by only one company
+- **centralized templates**, so no mechanism for composing pipelines from multiple repositories
+
+### Dagger
+
+**Pro**
+
+- Pipeline as code
+  - if it runs it should run anywhere and produce the "same" / somewhat stable results
+  - build environments are defined within containers / the dagger config. Dagger is the only dependency one has to install on a machine
+- DX is extremely nice, especially if you have to debug (image) builds, also type safety due to the ability to code your build in a strong language
+- additional tooling, like trivy, is added to a build pipeline with low effort due to containers and existing plugin/wrappers
+- you can create complex test environments similar to test containers and docker compose
+
+**Con**
+
+- relies heavily containers, which might not be available some environments (due to policy etc), it also has an effect on reproducibility and verifiability
+- as a dev you need to properly understand containers
+- dagger engine has to run privileged locally and/or in the cloud which might be a blocker or at least a big pain in the ...
+
+**Suggestion Patrick**
+
+- dagger is a heavy weight and might not be as productive in a dev workflow as it seems (setup lsp etc)
+- it might be too opinionated to force on teams, especially since it is not near mainstream enough, community might be too small
+- it feels like dagger gets you 95% of the way, but the remaining 5% are a real struggle
+- if we like it, we should check the popularity in the dev community before further considering as it has a direct impact on teams and their preferences

docs/technical-documentation/decisions/README.md

@@ -0,0 +1,5 @@
+# ADRs
+
+Architecture Decision Records (ADRs) are a way to capture the important architectural decisions made during the development of a project. They are a way to document the context, the decision, and the consequences of the decision. They are a way to keep track of the architectural decisions made in a project and to communicate them to the team.
+
+The [Markdown Architectural Decision Records](https://adr.github.io/madr/) (MADR) format is a simple and easy-to-use format for writing ADRs in Markdown.

docs/technical-documentation/decisions/_adr-template.md

@@ -0,0 +1,67 @@
+<!-- we need to disable MD025, because we use the different heading "ADR Template" in the homepage (see above) than it is foreseen in the template -->
+<!-- markdownlint-disable-next-line MD025 -->
+# {short title, representative of solved problem and found solution}
+
+## Context and Problem Statement
+
+{Describe the context and problem statement, e.g., in free form using two to three sentences or in the form of an illustrative story. You may want to articulate the problem in form of a question and add links to collaboration boards or issue management systems.}
+
+<!-- This is an optional element. Feel free to remove. -->
+## Decision Drivers
+
+* {decision driver 1, e.g., a force, facing concern, …}
+* {decision driver 2, e.g., a force, facing concern, …}
+* … <!-- numbers of drivers can vary -->
+
+## Considered Options
+
+* {title of option 1}
+* {title of option 2}
+* {title of option 3}
+* … <!-- numbers of options can vary -->
+
+## Decision Outcome
+
+Chosen option: "{title of option 1}", because {justification. e.g., only option, which meets k.o. criterion decision driver | which resolves force {force} | … | comes out best (see below)}.
+
+<!-- This is an optional element. Feel free to remove. -->
+### Consequences
+
+* Good, because {positive consequence, e.g., improvement of one or more desired qualities, …}
+* Bad, because {negative consequence, e.g., compromising one or more desired qualities, …}
+* … <!-- numbers of consequences can vary -->
+
+<!-- This is an optional element. Feel free to remove. -->
+### Confirmation
+
+{Describe how the implementation of/compliance with the ADR can/will be confirmed. Are the design that was decided for and its implementation in line with the decision made? E.g., a design/code review or a test with a library such as ArchUnit can help validate this. Not that although we classify this element as optional, it is included in many ADRs.}
+
+<!-- This is an optional element. Feel free to remove. -->
+## Pros and Cons of the Options
+
+### {title of option 1}
+
+<!-- This is an optional element. Feel free to remove. -->
+{example | description | pointer to more information | …}
+
+* Good, because {argument a}
+* Good, because {argument b}
+<!-- use "neutral" if the given argument weights neither for good nor bad -->
+* Neutral, because {argument c}
+* Bad, because {argument d}
+* … <!-- numbers of pros and cons can vary -->
+
+### {title of other option}
+
+{example | description | pointer to more information | …}
+
+* Good, because {argument a}
+* Good, because {argument b}
+* Neutral, because {argument c}
+* Bad, because {argument d}
+* …
+
+<!-- This is an optional element. Feel free to remove. -->
+## More Information
+
+{You might want to provide additional evidence/confidence for the decision outcome here and/or document the team agreement on the decision and/or define when/how this decision the decision should be realized and if/when it should be re-visited. Links to other decisions and resources might appear here as well.}

docs/technical-documentation/project/_index.md

@@ -0,0 +1,6 @@
+---
+title: Project
+weight: 5
+description: How we organize work and proceed as team, which decisions we made, what outputs and outcomes we have
+---
+

docs/technical-documentation/project/bootstrapping/_index.md

@@ -0,0 +1,7 @@
+---
+title: Bootstrapping Infrastructure
+weight: 30
+description: The cluster and the installed applications in the bootstrapping cluster
+---
+
+In order to be able to do useful work, we do need a number of applications right away. We're deploying these manually so we have the necessary basis for our work. Once the framework has been developed far enough, we will deploy this infrastructure with the framework itself.

docs/technical-documentation/project/bootstrapping/backup/_index.md

@@ -0,0 +1,84 @@
+---
+title: Backup of the Bootstrapping Cluster
+weight: 30
+description: Backup and Restore of the Contents of the Bootstrapping Cluster
+---
+
+## Velero
+
+We are using [Velero](https://velero.io/) for backup and restore of the deployed applications.
+
+## Installing Velero Tools
+
+To manage a Velero install in a cluster, you need to have Velero command line tools installed locally. Please follow the instructions for [Basic Install](https://velero.io/docs/v1.9/basic-install).
+
+## Setting Up Velero For a Cluster
+
+Installing and configuring Velero for a cluster can be accomplished with the CLI.
+
+1. Create a file with the credentials for the S3 compatible bucket that is storing the backups, for example `credentials.ini`.
+
+```ini
+[default]
+aws_access_key_id = "Access Key Value"
+aws_secret_access_key = "Secret Key Value"
+```
+
+2. Install Velero in the cluster
+
+```
+velero install \
+    --provider aws \
+    --plugins velero/velero-plugin-for-aws:v1.2.1 \
+    --bucket osc-backup \
+    --secret-file ./credentials.ini \
+    --use-volume-snapshots=false \
+    --use-node-agent=true \
+    --backup-location-config region=minio,s3ForcePathStyle="true",s3Url=https://obs.eu-de.otc.t-systems.com
+```
+
+3. Delete `credentials.ini`, it is not needed anymore (a secret has been created in the cluster).
+4. Create a schedule to back up the relevant resources in the cluster:
+```
+velero schedule create devfw-bootstrap --schedule="23 */2 * * *" "--include-namespaces=forgejo"
+```
+
+## Working with Velero
+
+You can now use Velero to create backups, restore them, or perform other operations. Please refer to the [Velero Documentation](https://velero.io/docs/main/backup-reference/).
+
+To list all currently available backups:
+```
+velero backup get
+```
+
+## Setting up a Service Account for Access to the OTC Object Storage Bucket
+
+We are using the S3-compatible Open Telekom Cloud Object Storage service to make available some storage for the backups. We picked OTC specifically because we're not using it for anything else, so no matter what catastrophy we create in Open Sovereign Cloud, the backups should be safe.
+
+### Create an Object Storage Service Bucket
+
+1. Log in to the [OTC Console with the correct tenant](https://auth.otc.t-systems.com/authui/federation/websso?domain_id=81e7dbd7ec9f4b03a58120dfaa61d3db&idp=ADFS_MMS_OTC00000000001000113497&protocol=saml).
+1. Navigate to [Object Storage Service](https://console.otc.t-systems.com/obs/?agencyId=WEXsFwkkVdGYULIrZT1icF4nmHY1dgX2&region=eu-de&locale=en-us#/obs/manager/buckets).
+1. Click Create Bucket in the upper right hand corner. Give your bucket a name. No further configuration should be necessary.
+
+### Create a Service User to Access the Bucket
+
+1. Log in to the [OTC Console with the correct tenant](https://auth.otc.t-systems.com/authui/federation/websso?domain_id=81e7dbd7ec9f4b03a58120dfaa61d3db&idp=ADFS_MMS_OTC00000000001000113497&protocol=saml).
+1. Navigate to [Identity and Access Management](https://console.otc.t-systems.com/iam/?agencyId=WEXsFwkkVdGYULIrZT1icF4nmHY1dgX2&region=eu-de&locale=en-us#/iam/users).
+1. Navigate to User Groups, and click Create User Group in the upper right hand corner.
+1. Enter a suitable name ("OSC Cloud Backup") and click OK.
+1. In the group list, locate the group just created and click its name.
+1. Click Authorize to add the necessary roles. Enter "OBS" in the search box to filter for Object Storage roles.
+1. Select "OBS OperateAccess", if there are two roles, select them both.
+1. **2024-10-15** Also select the "OBS Administrator" role. It is unclear why the "OBS OperateAccess" role is not sufficient, but without the admin role, the service user will not have write access to the bucket.
+1. Click Next to save the roles, then click OK to confirm, then click Finish.
+1. Navigate to Users, and click Create User in the upper right hand corner.
+1. Give the user a sensible name ("ipcei-cis-devfw-osc-backups").
+1. Disable Management console access
+1. Enable Access key, disable Password, disable Login protection.
+1. Click Next
+1. Pick the group created earlier.
+1. Download the access key when prompted.
+
+The access key is a CSV file with the Access Key and the Secret Key listed in the second line.

docs/technical-documentation/project/conceptual-onboarding/1_intro/_index.md

@@ -0,0 +1,49 @@
+---
+title: Introduction
+weight: 1
+description: The 5-step storyflow of this Onboarding chapter
+---
+
+{{% pageinfo color="info" %}}
+## Summary
+
+This onboarding section is for you when are new to IPCEI-CIS subproject 'Edge Developer Framework (EDF)' and you want to know about 
+* its context to 'Platform Engineering' 
+* and why we think it's the stuff we need to care about in the EDF
+{{% /pageinfo %}}
+
+
+## Storyline of our current project plan (2024)
+
+1. We have the ['Edge Developer Framework'](./edgel-developer-framework/)
+2. We think the solution for EDF is in relation to ['Platforming' (Digital Platforms)](./platforming/)
+    1. The next evolution after DevOps
+    2. Gartner predicts 80% of SWE companies to have platforms in 2026
+    3. Platforms have a history since roundabout 2019
+    4. CNCF has a working group which created capabilities and a maturity model
+3. Platforms evolve - nowadys there are [Platform Orchestrators](./orchestrators/)
+    1. Humanitec set up a Reference Architecture
+    2. There is this 'Orchestrator' thing - declaratively describe, customize and change platforms!
+4. Mapping our assumptions to the [CNOE solution](./cnoe/)
+    1. CNOE is a hot candidate to help and fulfill our platform building
+    2. CNOE aims to embrace change and customization!
+5. [Showtime CNOE](./cnoe-showtime/)
+
+
+## Please challenge this story!
+
+Please do not think this story and the underlying assumptions are carved in stone!
+
+1. Don't miss to further investigate and truely understand [**EDF specification needs**](./edgel-developer-framework/)
+2. Don't miss to further investigate and truely understand [**Platform capabilities on top of DevOps**](./platforming/)
+3. Don't miss to further investigate and truely understand [**Platform orchestration**](./orchestrators/)
+3. Don't miss to further investigate and truely understand [**specific orchestratiing solutions like CNOE**](./cnoe/)
+
+## Your role as 'Framework Engineer' in the Domain Architecture
+
+Pls be aware of the the following domain and task structure of our mission: 
+
+![](./conclusio/images/modern.png)
+
+
+

docs/technical-documentation/project/conceptual-onboarding/2_edge-developer-framework/_index.md

@@ -0,0 +1,56 @@
+---
+title: Edge Developer Framework
+weight: 2
+description: Driving requirements for a platform
+---
+
+{{% pageinfo color="info" %}}
+## Summary
+
+The 'Edge Developer Framework' is both the project and the product we are working for. Out of the leading 'Portfolio Document' 
+we derive requirements which are ought to be fulfilled by Platform Engineering. 
+
+**This is our claim!**
+
+{{% /pageinfo %}}
+
+## What are the specifications we know from the IPCEI-CIS Project Portfolio document
+
+> Reference: IPCEI-CIS Project Portfolio
+> Version 5.9, November 17, 2023
+
+### DTAG´s IPCEI-CIS Project Portfolio (p.12)
+
+e. Development of DTAG/TSI Edge Developer Framework
+
+* Goal: All developed innovations must be accessible to developer communities in a **highly  user-friendly and easy way**
+
+### Development of DTAG/TSI Edge Developer Framework (p.14)
+| capability | major novelties |||
+| -- | -- | -- | -- |
+| e.1. Edge Developer full service framework (SDK + day1 +day2 support for edge installations) | Adaptive CI/CD pipelines for heterogeneous edge environments | Decentralized and self healing deployment and management | edge-driven monitoring and analytics |
+| e.2. Built-in sustainability optimization in Edge developer framework | sustainability optimized edge-aware CI/CD tooling | sustainability-optimized configuration management | sustainability-optimized efficient deployment strategies |
+| e.3. Sustainable-edge management-optimized user interface for edge developers | sustainability optimized User Interface | Ai-Enabled intelligent experience | AI/ML-based automated user experience testing and optimization |
+
+### DTAG objectives & contributions (p.27)
+
+DTAG will also focus on developing an easy-to-use **Edge Developer framework for software 
+developers** to **manage the whole lifecycle of edge applications**, i.e. for **day-0-, day-1- and up to day-2-
+operations**. With this DTAG will strongly enable the ecosystem building for the entire IPCEI-CIS edge to 
+cloud continuum and ensure openness and accessibility for anyone or any company to make use and 
+further build on the edge to cloud continuum. Providing the use of the tool framework via an open-source approach will further reduce entry barriers and enhance the openness and accessibility for anyone or 
+any organization (see innovations e.).
+
+### WP Deliverables (p.170)
+
+e.1 Edge developer full-service framework
+
+This tool set and related best practices and guidelines will **adapt, enhance and further innovate DevOps principles** and 
+their related, necessary supporting technologies according to the specific requirements and constraints associated with edge or edge cloud development, in order to keep the healthy and balanced innovation path on both sides, 
+the (software) development side and the operations side in the field of DevOps.
+
+{{% pageinfo color="info" %}}
+### What comes next?
+
+[Next](../platforming/) we'll see how these requirements seem to be fulfilled by platforms!
+{{% /pageinfo %}}

docs/technical-documentation/project/conceptual-onboarding/3_platforming/_index.md

@@ -0,0 +1,112 @@
+---
+title: Platform Engineering aka Platforming
+linktitle: Platforming
+weight: 3
+description: DevOps is dead - long live next level DevOps in platforms
+---
+
+
+{{% pageinfo color="info" %}}
+## Summary
+
+Since 2010 we have DevOps. This brings increasing delivery speed and efficiency at scale. 
+But next we got high 'cognitive loads' for developers and production congestion due to engineering lifecycle complexity. 
+So we need on top of DevOps an instrumentation to ensure and enforce speed, quality, security in modern, cloud native software development. This instrumentation is called 'golden paths' in intenal develoepr platforms (IDP).
+{{% /pageinfo %}}
+
+
+## History of Platform Engineering
+
+Let's start with a look into the history of platform engineering. A good starting point is [Humanitec](https://humanitec.com/), as they nowadays are one of the biggest players (['the market leader in IDPs.'](https://internaldeveloperplatform.org/#how-we-curate-this-site)) in platform engineering. 
+
+They create lots of [beautiful articles and insights](https://humanitec.com/blog), their own [platform products](https://humanitec.com/products/) and [basic concepts for the platform architecture](https://humanitec.com/platform-engineering) (we'll meet this later on!).
+
+<img src="./humanitec-history.png" width="600" alt="https://platformengineering.org/blog/the-story-of-platform-engineering">
+
+
+### Further nice reference to the raise of platforms
+
+* [What we **call** a Platform](https://martinfowler.com/articles/talk-about-platforms.html)
+* [Platforms and the **cloud native** connection](https://developers.redhat.com/articles/2024/05/06/)what-platform-engineering-and-why-do-we-need-it#why_we_need_platform_engineering
+* [Platforms and **microservices**](https://orkohunter.net/blog/a-brief-history-of-platform-engineering)
+* [Platforms in the **product** perspective](https://softwareengineeringdaily.com/2020/02/13/setting-the-stage-for-platform-engineering/)
+
+
+## Benefit of Platform Engineering, Capabilities
+
+In [The Evolution of Platform Engineering](https://www.linkedin.com/pulse/evolution-platform-engineering-gaurav-goel) the interconnection inbetween  DevOps, Cloud Native, and the Rise of Platform Engineering is nicely presented and summarizes:
+
+> Platform engineering can be broadly defined as the discipline of designing and building toolchains and workflows that enable self-service capabilities for software engineering organizations
+
+When looking at these 'capabilities', we have CNCF itself:
+
+### CNCF Working group / White paper defines layerwed capabilities
+
+There is a CNCF working group which provides the definition of [Capabilities of platforms](https://tag-app-delivery.cncf.io/whitepapers/platforms/#capabilities-of-platforms) and shows a first idea of the layered architecture of platforms as **service layer for developers** ("product and application teams"):
+
+<img src="./platforms-def.drawio.png" width="600">
+
+
+> Important: As Platform engineer also notice the [platform-eng-maturity-model](https://tag-app-delivery.cncf.io/whitepapers/platform-eng-maturity-model/)
+
+### Platform Engineering Team
+
+Or, in another illustration for the platform as a developer service interface, which also defines the **'Platform Engineering Team'** inbetween: 
+
+<img src="./platform-self-services.webp" width="600" alt="https://medium.com/@bijit211987/what-is-platform-engineering-and-how-it-reduce-cognitive-load-on-developers-ac7805603925">
+
+## How to set up Platforms
+
+As we now have evidence about the nescessity of platforms, their capabilities and benefit as self service layer for developers, we want to thin about how to build them.
+
+First of all some important wording to motivate the important term 'internal developer platfoms' (we will go into this deeper in the next section [with the general architecture](../orchestrators/)), which is clear today, but took years to evolve and [is still some amount if effort to jump in](https://humanitec.com/blog/wtf-internal-developer-platform-vs-internal-developer-portal-vs-paas):
+
+* Platform: As defined above: A product which serves software engineering teams
+* Platform Engineering: Creating such a product
+* Internal Developer Platforms (IDP): A platform for developers :-)
+* Internal Developer Portal: The entry point of a developer to such an IDP
+
+### CNCF mapping from capabilities to (CNCF) projects/tools
+
+[Capabilities of platforms](https://tag-app-delivery.cncf.io/whitepapers/platforms/#capabilities-of-platforms)
+
+### Ecosystems in InternalDeveloperPlatform 
+
+Build or buy - this is also in pltaform engineering a tweaked discussion, which one of the oldest player answers like this with some oppinioated internal capability structuring:
+
+[internaldeveloperplatform.org[(https://internaldeveloperplatform.org/platform-tooling/)
+
+
+{{% pageinfo color="info" %}}
+### What comes next?
+
+[Next](../orchestrators/) we'll see how these concepts got structured!
+{{% /pageinfo %}}
+
+## Addendum
+
+### Digital Platform defintion from [What we **call** a Platform](https://martinfowler.com/articles/talk-about-platforms.html)
+
+> Words are hard, it seems. ‘Platform’ is just about the most ambiguous term we could use for an approach that is super-important for increasing delivery speed and efficiency at scale. Hence the title of this article, here is what I’ve been talking about most recently. 
+\
+Definitions for software and hardware platforms abound, generally describing an operating environment upon which applications can execute and which provides reusable capabilities such as file systems and security.
+\
+Zooming out, at an organisational level a ‘digital platform’ has similar characteristics - an operating environment which teams can build upon to deliver product features to customers more quickly, supported by reusable capabilities.
+\
+A digital platform is a foundation of self-service APIs, tools, services, knowledge and support which are arranged as a compelling internal product. Autonomous delivery teams can make use of the platform to deliver product features at a higher pace, with reduced co-ordination.
+
+### Myths :-) - What are platforms _not_
+
+[common-myths-about-platform-engineering](https://cloud.google.com/blog/products/application-development/common-myths-about-platform-engineering?hl=en)
+
+### Platform Teams
+
+This is about you :-), the platform engineering team:
+
+[how-to-build-your-platform-engineering-team](https://platformengineering.org/blog/how-to-build-your-platform-engineering-team)
+
+#### in comparison: devops vs sre vs platform
+
+https://www.qovery.com/blog/devops-vs-platform-engineering-is-there-a-difference/
+
+![teams-in-comparison](teams.png)

docs/technical-documentation/project/conceptual-onboarding/4_orchestrators/_index.md

@@ -0,0 +1,53 @@
+---
+title: Orchestrators
+weight: 4
+description: Next level platforming is orchestrating platforms
+---
+
+{{% pageinfo color="info" %}}
+## Summary
+
+When defining and setting up platforms next two intrinsic problems arise: 
+1. it is not declarative and automated
+2. it is not or least not easily changable
+
+Thus the technology of 'Platform Orchestrating' emerged recently, in late 2023.
+
+{{% /pageinfo %}}
+
+## Platform reference architecture
+
+An interesting difference between the CNCF white paper building blocks and them from Internaldeveloperplatforms is the part [**orchestrators**](https://internaldeveloperplatform.org/platform-orchestrators/).
+
+This is something extremely new since late 2023 - the rise of the automation of platform engineering!
+
+It was Humanitec creating a definition of platform architecture, as they needed to defien what they are building with their 'orchestrator':
+
+<img src="./vendor-neutral-idp-final.gif" width="600" alt="https://developer.humanitec.com/introduction/overview/">
+
+## Declarative Platform Orchestration
+
+Based on the refence architecture you next can build - or let's say 'orchestrate' - different platform implementations, based on declarative definitions of the platform design.
+
+https://humanitec.com/reference-architectures
+
+<img src="./platform-architectures.webp" width="600" alt="https://humanitec.com/blog/aws-azure-and-gcp-open-source-reference-architectures-to-start-your-mvp">
+
+> Hint: There is a [slides tool provided by McKinsey](https://platformengineering.org/blog/create-your-own-platform-engineering-reference-architectures) to set up your own platform deign based on the reference architecture 
+
+
+{{% pageinfo color="info" %}}
+### What comes next?
+
+[Next](../cnoe/) we'll see how we are going to do platform orchestration with CNOE!
+{{% /pageinfo %}}
+
+## Addendum
+
+## Building blocks from Humanitecs 'state-of-platform-engineering-report-volume-2'
+
+You remember the [capability mappings from the time before orchestration](../platforming)? Here we have a [similar setup based on Humanitecs platform engineering status ewhite paper](https://humanitec.com/whitepapers/state-of-platform-engineering-report-volume-2):
+
+<img src="./platform-tooling-humanitec-platform-report-2024.PNG" width="600" alt="https://humanitec.com/whitepapers/state-of-platform-engineering-report-volume-2 Whitepaper_ State of Platform Engineering Report.pdf">
+
+

docs/technical-documentation/project/conceptual-onboarding/5_cnoe/_index.md

@@ -0,0 +1,61 @@
+---
+title: CNOE
+weight: 5
+description: Our top candidate for a platform orchestrator
+---
+
+{{% pageinfo color="info" %}}
+## Summary
+
+In late 2023 platform orchestration raised - the discipline of declarativley dinfing, building, orchestarting and reconciling building blocks of (digital) platforms.
+
+The famost one ist the platform orchestrator from Humanitec. They provide lots of concepts and access, also open sourced tools and schemas. But they do not have open sourced the ocheastartor itself.
+
+Thus we were looking for open source means for platform orchestrating and found [CNOE](https://cnoe.io).
+{{% /pageinfo %}}
+
+## Requirements for an Orchestrator
+
+When we want to set up a [complete platform](../platforming/platforms-def.drawio.png) we expect to have
+* a **schema** which defines the platform, its ressources and internal behaviour
+* a **dynamic configuration or templating mechanism** to provide a concrete specification of a platform
+* a **deployment mechanism** to deploy and reconcile the platform
+
+This is what [CNOE delivers](https://cnoe.io/docs/intro/approach):
+
+> For seamless transition into a CNOE-compliant delivery pipeline, CNOE will aim at delivering **"packaging specifications"**, **"templating mechanisms"**, as well as **"deployer technologies"**, an example of which is enabled via the idpBuilder tool we have released. The combination of templates, specifications, and deployers allow for bundling and then unpacking of CNOE recommended tools into **a user's DevOps environment**. This enables teams to share and deliver components that are deemed to be the best tools for the job.
+
+## CNOE (capabilities) architecture
+
+### Architecture
+
+CNOE architecture looks a bit different than the reference architecture from Humanitec, but this just a matter of details and arrangement:
+
+> Hint: **This has to be further investigated!** This is subject to an Epic.
+
+<img src="./cnoe-architecture.png" width="600" alt="https://cnoe.io/">
+
+### Capabilities
+
+You have a [definition of all the capabilities here](https://cnoe.io/docs/category/technology-capabilities):
+
+> Hint: **This has to be further investigated!** This is subject to an Epic.
+
+<img src="./cnoe-capabilities.png" width="600" alt="https://cnoe.io/docs/category/technology-capabilities">
+
+## Stacks
+
+CNOE calls the [schema and templating mechnanism 'stacks'](https://github.com/cnoe-io/stacks):
+
+> Hint: **This has to be further investigated!** This is subject to an Epic.
+
+There are already some example stacks:
+
+<img src="./cnoe-stacks.png" width="600">
+
+
+{{% pageinfo color="info" %}}
+### What comes next?
+
+[Next](../cnoe-showtime/) we'll see how a CNOE stacked Internal Developer Platform is deployed on you local laptop!
+{{% /pageinfo %}}

docs/technical-documentation/project/conceptual-onboarding/6_cnoe-showtime/_index.md

@@ -0,0 +1,580 @@
+---
+title: CNOE Showtime
+weight: 6
+description: CNOE hands on
+---
+
+{{% pageinfo color="info" %}}
+## Summary
+
+CNOE is a 'Platform Engineering Framework' (Danger: Our wording!) - it is open source and locally runnable. 
+
+It consists of the orchestrator 'idpbuilder' and both of some predefined building blocks and also some predefined platform configurations.  
+
+{{% /pageinfo %}}
+
+
+## Orchestrator 'idpbuilder', initial run
+
+The orchestrator in CNOE is called 'idpbuilder'. It is [locally installable binary](https://cnoe.io/docs/reference-implementation/installations/idpbuilder/quick-start)
+
+A typipcal first setup ist described here: https://cnoe.io/docs/reference-implementation/technology
+
+```bash
+# this is a local linux shell
+
+# check local installation
+type idpbuilder
+idpbuilder is /usr/local/bin/idpbuilder
+
+# check version
+idpbuilder version
+idpbuilder 0.8.0-nightly.20240914 go1.22.7 linux/amd64
+
+# do some completion and aliasing
+source <(idpbuilder completion bash)
+alias ib=idpbuilder
+complete -F __start_idpbuilder ib
+
+# check and remove all existing kind clusters
+kind delete clusters --all
+kind get clusters
+# sth. like 'No kind clusters found.'
+
+# run
+$ib create --use-path-routing  --log-level debug --package-dir https://github.com/cnoe-io/stacks//ref-implementation
+```
+
+You get output like
+
+```bash
+stl@ubuntu-vpn:~/git/mms/ipceicis-developerframework$ idpbuilder create
+Oct  1 10:09:18 INFO Creating kind cluster logger=setup
+Oct  1 10:09:18 INFO Runtime detected logger=setup provider=docker
+########################### Our kind config ############################
+# Kind kubernetes release images https://github.com/kubernetes-sigs/kind/releases
+kind: Cluster
+apiVersion: kind.x-k8s.io/v1alpha4
+nodes:
+- role: control-plane
+  image: "kindest/node:v1.30.0"
+  labels:
+    ingress-ready: "true"
+  extraPortMappings:
+  - containerPort: 443
+    hostPort: 8443
+    protocol: TCP
+
+containerdConfigPatches:
+- |-
+  [plugins."io.containerd.grpc.v1.cri".registry.mirrors."gitea.cnoe.localtest.me:8443"]
+    endpoint = ["https://gitea.cnoe.localtest.me"]
+  [plugins."io.containerd.grpc.v1.cri".registry.configs."gitea.cnoe.localtest.me".tls]
+    insecure_skip_verify = true
+
+#########################   config end    ############################
+```
+
+## Show time steps
+
+> Goto https://cnoe.io/docs/reference-implementation/installations/idpbuilder/usage, and follow the flow
+
+### Prepare a k8s cluster with kind
+
+You may have seen: when starting `idpbuilder` without an existing cluster named `localdev` it first creates this cluster by calling `kind`with an internally defined config.
+
+It's an important feature of idpbuilder that it will set up on an existing cluster `localdev` when called several times in a row e.g. to append new packages to the cluster.
+
+That's why we here first create the kind cluster `localdev`itself:
+
+```bash 
+cat << EOF | kind create cluster --name localdev --config=-
+# Kind kubernetes release images https://github.com/kubernetes-sigs/kind/releases
+kind: Cluster
+apiVersion: kind.x-k8s.io/v1alpha4
+nodes:
+- role: control-plane
+  image: "kindest/node:v1.30.0"
+  labels:
+    ingress-ready: "true"
+  extraPortMappings:
+  - containerPort: 443
+    hostPort: 8443
+    protocol: TCP
+
+containerdConfigPatches:
+- |-
+  [plugins."io.containerd.grpc.v1.cri".registry.mirrors."gitea.cnoe.localtest.me:8443"]
+    endpoint = ["https://gitea.cnoe.localtest.me"]
+  [plugins."io.containerd.grpc.v1.cri".registry.configs."gitea.cnoe.localtest.me".tls]
+    insecure_skip_verify = true
+```
+
+```bash
+# alternatively, if you have the kind config as file:
+kind create cluster --name localdev --config kind-config.yaml
+```
+
+#### Output
+
+A typical raw kind setup kubernetes cluster would look like this with respect to running pods:
+
+> be sure all pods are in status 'running'
+
+```bash
+stl@ubuntu-vpn:~/git/mms/idpbuilder$ k get pods -A
+NAMESPACE            NAME                                             READY   STATUS    RESTARTS   AGE
+kube-system          coredns-76f75df574-lb7jz                         1/1     Running   0          15s
+kube-system          coredns-76f75df574-zm2wp                         1/1     Running   0          15s
+kube-system          etcd-localdev-control-plane                      1/1     Running   0          27s
+kube-system          kindnet-8qhd5                                    1/1     Running   0          13s
+kube-system          kindnet-r4d6n                                    1/1     Running   0          15s
+kube-system          kube-apiserver-localdev-control-plane            1/1     Running   0          27s
+kube-system          kube-controller-manager-localdev-control-plane   1/1     Running   0          27s
+kube-system          kube-proxy-vrh64                                 1/1     Running   0          15s
+kube-system          kube-proxy-w8ks9                                 1/1     Running   0          13s
+kube-system          kube-scheduler-localdev-control-plane            1/1     Running   0          27s
+local-path-storage   local-path-provisioner-6f8956fb48-6fvt2          1/1     Running   0          15s
+```
+
+### First run: Start with core applications, 'core package' 
+
+Now we run idpbuilder the first time:
+
+```
+# now idpbuilder reuses the already existing cluster
+# pls apply '--use-path-routing' otherwise as we discovered currently the service resolving inside the cluster won't work 
+ib create --use-path-routing
+```
+
+#### Output
+
+##### idpbuilder log 
+
+```bash
+stl@ubuntu-vpn:~/git/mms/idpbuilder$ ib create --use-path-routing
+Oct  1 10:32:50 INFO Creating kind cluster logger=setup
+Oct  1 10:32:50 INFO Runtime detected logger=setup provider=docker
+Oct  1 10:32:50 INFO Cluster already exists logger=setup cluster=localdev
+Oct  1 10:32:50 INFO Adding CRDs to the cluster logger=setup
+Oct  1 10:32:51 INFO Setting up CoreDNS logger=setup
+Oct  1 10:32:51 INFO Setting up TLS certificate logger=setup
+Oct  1 10:32:51 INFO Creating localbuild resource logger=setup
+Oct  1 10:32:51 INFO Starting EventSource controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository source=kind source: *v1alpha1.GitRepository
+Oct  1 10:32:51 INFO Starting Controller controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository
+Oct  1 10:32:51 INFO Starting EventSource controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild source=kind source: *v1alpha1.Localbuild
+Oct  1 10:32:51 INFO Starting Controller controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild
+Oct  1 10:32:51 INFO Starting EventSource controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage source=kind source: *v1alpha1.CustomPackage
+Oct  1 10:32:51 INFO Starting Controller controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage
+Oct  1 10:32:51 INFO Starting workers controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild worker count=1
+Oct  1 10:32:51 INFO Starting workers controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage worker count=1
+Oct  1 10:32:51 INFO Starting workers controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository worker count=1
+Oct  1 10:32:54 INFO Waiting for Deployment my-gitea to become ready controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:32:54 INFO Waiting for Deployment ingress-nginx-controller to become ready controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:33:24 INFO Waiting for Deployment my-gitea to become ready controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:33:24 INFO Waiting for Deployment ingress-nginx-controller to become ready controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:33:54 INFO Waiting for Deployment my-gitea to become ready controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:34:24 INFO installing bootstrap apps to ArgoCD controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:34:24 INFO expected annotation, cnoe.io/last-observed-cli-start-time, not found controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:34:24 INFO Checking if we should shutdown controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=6fc396d4-e0d5-4c80-aaee-20c1bbffea54
+Oct  1 10:34:25 INFO installing bootstrap apps to ArgoCD controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=0667fa85-af1c-403f-bcd9-16ff8f2fad7e
+Oct  1 10:34:25 INFO expected annotation, cnoe.io/last-observed-cli-start-time, not found controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=0667fa85-af1c-403f-bcd9-16ff8f2fad7e
+Oct  1 10:34:25 INFO Checking if we should shutdown controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=0667fa85-af1c-403f-bcd9-16ff8f2fad7e
+Oct  1 10:34:40 INFO installing bootstrap apps to ArgoCD controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=ec720aeb-02cd-4974-a991-cf2f19ce8536
+Oct  1 10:34:40 INFO Checking if we should shutdown controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=ec720aeb-02cd-4974-a991-cf2f19ce8536
+Oct  1 10:34:40 INFO Shutting Down controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=ec720aeb-02cd-4974-a991-cf2f19ce8536
+Oct  1 10:34:40 INFO Stopping and waiting for non leader election runnables
+Oct  1 10:34:40 INFO Stopping and waiting for leader election runnables
+Oct  1 10:34:40 INFO Shutdown signal received, waiting for all workers to finish controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository
+Oct  1 10:34:40 INFO Shutdown signal received, waiting for all workers to finish controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage
+Oct  1 10:34:40 INFO All workers finished controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage
+Oct  1 10:34:40 INFO Shutdown signal received, waiting for all workers to finish controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild
+Oct  1 10:34:40 INFO All workers finished controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild
+Oct  1 10:34:40 INFO All workers finished controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository
+Oct  1 10:34:40 INFO Stopping and waiting for caches
+Oct  1 10:34:40 INFO Stopping and waiting for webhooks
+Oct  1 10:34:40 INFO Stopping and waiting for HTTP servers
+Oct  1 10:34:40 INFO Wait completed, proceeding to shutdown the manager
+
+
+########################### Finished Creating IDP Successfully! ############################
+
+
+Can Access ArgoCD at https://cnoe.localtest.me:8443/argocd
+Username: admin
+Password can be retrieved by running: idpbuilder get secrets -p argocd
+```
+
+##### ArgoCD applications
+
+When running idpbuilder 'barely' (without package option) you get the 'core applications' deployed in your cluster:
+
+```bash
+stl@ubuntu-vpn:~/git/mms/ipceicis-developerframework$ k get applications -A
+NAMESPACE   NAME     SYNC STATUS   HEALTH STATUS
+argocd      argocd   Synced        Healthy
+argocd      gitea    Synced        Healthy
+argocd      nginx    Synced        Healthy
+```
+
+##### ArgoCD UI
+
+Open ArgoCD locally:
+
+https://cnoe.localtest.me:8443/argocd
+
+![alt text](image.png)
+
+Next find the provided credentials for ArgoCD (here: argocd-initial-admin-secret):
+
+```bash
+stl@ubuntu-vpn:~/git/mms/idpbuilder$ ib get secrets
+---------------------------
+Name: argocd-initial-admin-secret
+Namespace: argocd
+Data:
+  password : 2MoMeW30wSC9EraF
+  username : admin
+---------------------------
+Name: gitea-credential
+Namespace: gitea
+Data:
+  password : LI$T?o>N{-<|{^dm$eTg*gni1(2:Y0@q344yqQIS
+  username : giteaAdmin
+```
+
+In ArgoCD you will see the deployed three applications of the core package: 
+
+![alt text](image-1.png)
+
+### Second run: Append 'package1' from the CNOE-stacks repo
+
+CNOE provides example packages in `https://github.com/cnoe-io/stacks.git`. Having cloned this repo you can locally refer to theses packages:
+
+```bash
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ git remote -v
+origin  https://github.com/cnoe-io/stacks.git (fetch)
+origin  https://github.com/cnoe-io/stacks.git (push)
+```
+
+```bash
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ ls -al
+total 64
+drwxr-xr-x 12 stl stl  4096 Sep 28 13:55 .
+drwxr-xr-x 26 stl stl  4096 Sep 30 11:53 ..
+drwxr-xr-x  8 stl stl  4096 Sep 28 13:56 .git
+drwxr-xr-x  4 stl stl  4096 Jul 29 10:57 .github
+-rw-r--r--  1 stl stl 11341 Sep 28 09:12 LICENSE
+-rw-r--r--  1 stl stl  1079 Sep 28 13:55 README.md
+drwxr-xr-x  4 stl stl  4096 Jul 29 10:57 basic
+drwxr-xr-x  4 stl stl  4096 Sep 14 15:54 crossplane-integrations
+drwxr-xr-x  3 stl stl  4096 Aug 13 14:52 dapr-integration
+drwxr-xr-x  3 stl stl  4096 Sep 14 15:54 jupyterhub
+drwxr-xr-x  6 stl stl  4096 Aug 16 14:36 local-backup
+drwxr-xr-x  3 stl stl  4096 Aug 16 14:36 localstack-integration
+drwxr-xr-x  8 stl stl  4096 Sep 28 13:02 ref-implementation
+drwxr-xr-x  2 stl stl  4096 Aug 16 14:36 terraform-integrations
+
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ ls -al basic/
+total 20
+drwxr-xr-x  4 stl stl 4096 Jul 29 10:57 .
+drwxr-xr-x 12 stl stl 4096 Sep 28 13:55 ..
+-rw-r--r--  1 stl stl  632 Jul 29 10:57 README.md
+drwxr-xr-x  3 stl stl 4096 Jul 29 10:57 package1
+drwxr-xr-x  2 stl stl 4096 Jul 29 10:57 package2
+
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ ls -al basic/package1
+total 16
+drwxr-xr-x 3 stl stl 4096 Jul 29 10:57 .
+drwxr-xr-x 4 stl stl 4096 Jul 29 10:57 ..
+-rw-r--r-- 1 stl stl  655 Jul 29 10:57 app.yaml
+drwxr-xr-x 2 stl stl 4096 Jul 29 10:57 manifests
+
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ ls -al basic/package2
+total 16
+drwxr-xr-x 2 stl stl 4096 Jul 29 10:57 .
+drwxr-xr-x 4 stl stl 4096 Jul 29 10:57 ..
+-rw-r--r-- 1 stl stl  498 Jul 29 10:57 app.yaml
+-rw-r--r-- 1 stl stl  500 Jul 29 10:57 app2.yaml
+```
+
+#### Output
+
+Now we run idpbuilder the second time with `-p basic/package1`
+
+##### idpbuilder log 
+
+```bash
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ ib create --use-path-routing -p basic/package1
+Oct  1 12:09:27 INFO Creating kind cluster logger=setup
+Oct  1 12:09:27 INFO Runtime detected logger=setup provider=docker
+Oct  1 12:09:27 INFO Cluster already exists logger=setup cluster=localdev
+Oct  1 12:09:28 INFO Adding CRDs to the cluster logger=setup
+Oct  1 12:09:28 INFO Setting up CoreDNS logger=setup
+Oct  1 12:09:28 INFO Setting up TLS certificate logger=setup
+Oct  1 12:09:28 INFO Creating localbuild resource logger=setup
+Oct  1 12:09:28 INFO Starting EventSource controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild source=kind source: *v1alpha1.Localbuild
+Oct  1 12:09:28 INFO Starting Controller controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild
+Oct  1 12:09:28 INFO Starting EventSource controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage source=kind source: *v1alpha1.CustomPackage
+Oct  1 12:09:28 INFO Starting Controller controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage
+Oct  1 12:09:28 INFO Starting EventSource controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository source=kind source: *v1alpha1.GitRepository
+Oct  1 12:09:28 INFO Starting Controller controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository
+Oct  1 12:09:28 INFO Starting workers controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild worker count=1
+Oct  1 12:09:28 INFO Starting workers controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository worker count=1
+Oct  1 12:09:28 INFO Starting workers controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage worker count=1
+Oct  1 12:09:29 INFO installing bootstrap apps to ArgoCD controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=0ed7ccc2-dec7-4ab8-909c-791a7d1b67a8
+Oct  1 12:09:29 INFO unknown field "status.history[0].initiatedBy" logger=KubeAPIWarningLogger
+Oct  1 12:09:29 INFO Checking if we should shutdown controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=0ed7ccc2-dec7-4ab8-909c-791a7d1b67a8
+Oct  1 12:09:29 ERROR failed updating repo status controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage name=app-my-app namespace=idpbuilder-localdev namespace=idpbuilder-localdev name=app-my-app reconcileID=f9873560-5dcd-4e59-b6f7-ce5d1029ef3d err=Operation cannot be fulfilled on custompackages.idpbuilder.cnoe.io "app-my-app": the object has been modified; please apply your changes to the latest version and try again
+Oct  1 12:09:29 ERROR Reconciler error controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage name=app-my-app namespace=idpbuilder-localdev namespace=idpbuilder-localdev name=app-my-app reconcileID=f9873560-5dcd-4e59-b6f7-ce5d1029ef3d err=updating argocd application object my-app: Operation cannot be fulfilled on applications.argoproj.io "my-app": the object has been modified; please apply your changes to the latest version and try again
+Oct  1 12:09:31 INFO installing bootstrap apps to ArgoCD controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=531cc2d4-6250-493a-aca8-fecf048a608d
+Oct  1 12:09:31 INFO Checking if we should shutdown controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=531cc2d4-6250-493a-aca8-fecf048a608d
+Oct  1 12:09:44 INFO installing bootstrap apps to ArgoCD controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=022b9813-8708-4f4e-90d7-38f1e114c46f
+Oct  1 12:09:44 INFO Checking if we should shutdown controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=022b9813-8708-4f4e-90d7-38f1e114c46f
+Oct  1 12:10:00 INFO installing bootstrap apps to ArgoCD controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=79a85c21-42c1-41ec-ad03-2bb77aeae027
+Oct  1 12:10:00 INFO Checking if we should shutdown controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=79a85c21-42c1-41ec-ad03-2bb77aeae027
+Oct  1 12:10:00 INFO Shutting Down controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild name=localdev name=localdev reconcileID=79a85c21-42c1-41ec-ad03-2bb77aeae027
+Oct  1 12:10:00 INFO Stopping and waiting for non leader election runnables
+Oct  1 12:10:00 INFO Stopping and waiting for leader election runnables
+Oct  1 12:10:00 INFO Shutdown signal received, waiting for all workers to finish controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage
+Oct  1 12:10:00 INFO Shutdown signal received, waiting for all workers to finish controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository
+Oct  1 12:10:00 INFO All workers finished controller=custompackage controllerGroup=idpbuilder.cnoe.io controllerKind=CustomPackage
+Oct  1 12:10:00 INFO Shutdown signal received, waiting for all workers to finish controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild
+Oct  1 12:10:00 INFO All workers finished controller=localbuild controllerGroup=idpbuilder.cnoe.io controllerKind=Localbuild
+Oct  1 12:10:00 INFO All workers finished controller=gitrepository controllerGroup=idpbuilder.cnoe.io controllerKind=GitRepository
+Oct  1 12:10:00 INFO Stopping and waiting for caches
+Oct  1 12:10:00 INFO Stopping and waiting for webhooks
+Oct  1 12:10:00 INFO Stopping and waiting for HTTP servers
+Oct  1 12:10:00 INFO Wait completed, proceeding to shutdown the manager
+
+
+########################### Finished Creating IDP Successfully! ############################
+
+
+Can Access ArgoCD at https://cnoe.localtest.me:8443/argocd
+Username: admin
+Password can be retrieved by running: idpbuilder get secrets -p argocd
+```
+
+##### ArgoCD applications
+
+Now we have additionally the 'my-app' deployed in the cluster:
+
+```bash
+stl@ubuntu-vpn:~$ k get applications -A
+NAMESPACE   NAME     SYNC STATUS   HEALTH STATUS
+argocd      argocd   Synced        Healthy
+argocd      gitea    Synced        Healthy
+argocd      my-app   Synced        Healthy
+argocd      nginx    Synced        Healthy
+```
+
+##### ArgoCD UI
+
+![alt text](image-2.png)
+
+### Third run: Finally we append 'ref-implementation' from the CNOE-stacks repo
+
+We finally append the so called ['reference-implementation'](https://cnoe.io/docs/reference-implementation/integrations/reference-impl), which provides a real basic IDP:
+
+```bash
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ ib create --use-path-routing -p ref-implementation
+```
+
+##### ArgoCD applications
+
+```bash
+stl@ubuntu-vpn:~$ k get applications -A
+NAMESPACE   NAME                  SYNC STATUS   HEALTH STATUS
+argocd      argo-workflows        Synced        Healthy
+argocd      argocd                Synced        Healthy
+argocd      backstage             Synced        Healthy
+argocd      included-backstage-templates   Synced        Healthy
+argocd      external-secrets      Synced        Healthy
+argocd      gitea                 Synced        Healthy
+argocd      keycloak              Synced        Healthy
+argocd      metric-server         Synced        Healthy
+argocd      my-app                Synced        Healthy
+argocd      nginx                 Synced        Healthy
+argocd      spark-operator        Synced        Healthy
+```
+
+##### ArgoCD UI
+
+ArgoCD shows all provissioned applications:
+
+![alt text](image-3.png)
+
+##### Keycloak UI
+
+In our cluster there is also keycloak as IAM provisioned.  
+Login into Keycloak with 'cnoe-admin' and the KEYCLOAK_ADMIN_PASSWORD.
+
+These credentails are defined in the package:
+
+```bash
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ cat ref-implementation/keycloak/manifests/keycloak-config.yaml | grep -i admin
+  group-admin-payload.json: |
+    {"name":"admin"}
+          "/admin"
+              ADMIN_PASSWORD=$(cat /var/secrets/KEYCLOAK_ADMIN_PASSWORD)
+                --data-urlencode "username=cnoe-admin" \
+                --data-urlencode "password=${ADMIN_PASSWORD}" \
+```
+
+```bash
+stl@ubuntu-vpn:~/git/mms/cnoe-stacks$ ib get secrets
+---------------------------
+Name: argocd-initial-admin-secret
+Namespace: argocd
+Data:
+  password : 2MoMeW30wSC9EraF
+  username : admin
+---------------------------
+Name: gitea-credential
+Namespace: gitea
+Data:
+  password : LI$T?o>N{-<|{^dm$eTg*gni1(2:Y0@q344yqQIS
+  username : giteaAdmin
+---------------------------
+Name: keycloak-config
+Namespace: keycloak
+Data:
+  KC_DB_PASSWORD : k3-1kgxxd/X2Cw//pX-uKMsmgWogEz5YGnb5
+  KC_DB_USERNAME : keycloak
+  KEYCLOAK_ADMIN_PASSWORD : zMSjv5eA0l/+0-MDAaaNe+rHRMrB2q0NssP-
+  POSTGRES_DB : keycloak
+  POSTGRES_PASSWORD : k3-1kgxxd/X2Cw//pX-uKMsmgWogEz5YGnb5
+  POSTGRES_USER : keycloak
+  USER_PASSWORD : Kd+0+/BqPRAvnLPZO-L2o/6DoBrzUeMsr29U
+```
+
+![alt text](image-4.png)
+
+
+##### Backstage UI
+
+As Backstage login you either can use the 'user1' with `USER_PASSWORD : Kd+0+/BqPRAvnLPZO-L2o/6DoBrzUeMsr29U` or you create a new user in keycloak
+
+![](image-6.png)
+
+We create user 'ipcei' and also set a password (in tab 'Credentials'):
+
+![alt text](image-7.png)
+
+Now we can log into backstage (rember: you could have already existing usr 'user1'):
+
+![alt text](image-8.png)
+
+and see the basic setup of the Backstage portal:
+
+![alt text](image-9.png)
+
+### Use a Golden Path: 'Basic Deployment'
+
+Now we want to use the Backstage portal as a developer. We create in Backstage our own platform based activity by using the golden path template 'Basic Deployment:
+
+![alt text](image-10.png)
+
+When we run it, we see 'golden path activities'
+
+![alt text](image-11.png)
+
+which finally result in a new catalogue entry:
+
+![alt text](image-12.png)
+
+#### Software development lifecycle
+
+When we follow the 'view source' link we are directly linked to the git repo of our newly created application:
+
+![alt text](image-13.png)
+
+Check it out by cloning into a local git repo (watch the GIT_SSL_NO_VERIFY=true env setting):
+
+```bash
+stl@ubuntu-vpn:~/git/mms/idp-temporary$ GIT_SSL_NO_VERIFY=true git clone https://cnoe.localtest.me:8443/gitea/giteaAdmin/basicdeployment.git
+Cloning into 'basicdeployment'...
+remote: Enumerating objects: 10, done.
+remote: Counting objects: 100% (10/10), done.
+remote: Compressing objects: 100% (8/8), done.
+remote: Total 10 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
+Receiving objects: 100% (10/10), 47.62 KiB | 23.81 MiB/s, done.
+
+stl@ubuntu-vpn:~/git/mms/idp-temporary$ cd basicdeployment/
+
+stl@ubuntu-vpn:~/git/mms/idp-temporary/basicdeployment$ ll
+total 24
+drwxr-xr-x 5 stl stl 4096 Oct  1 13:00 ./
+drwxr-xr-x 4 stl stl 4096 Oct  1 13:00 ../
+drwxr-xr-x 8 stl stl 4096 Oct  1 13:00 .git/
+-rw-r--r-- 1 stl stl  928 Oct  1 13:00 catalog-info.yaml
+drwxr-xr-x 3 stl stl 4096 Oct  1 13:00 docs/
+drwxr-xr-x 2 stl stl 4096 Oct  1 13:00 manifests/
+```
+
+#### Edit and change
+
+Change some things, like the decription and the replicas:
+
+![alt text](image-16.png)
+
+#### Push
+
+Push your changes, use the giteaAdmin user to authenticate:
+
+```bash
+stl@ubuntu-vpn:~/git/mms/idp-temporary/basicdeployment$ ib get secrets
+---------------------------
+Name: argocd-initial-admin-secret
+Namespace: argocd
+Data:
+  password : 2MoMeW30wSC9EraF
+  username : admin
+---------------------------
+Name: gitea-credential
+Namespace: gitea
+Data:
+  password : LI$T?o>N{-<|{^dm$eTg*gni1(2:Y0@q344yqQIS
+  username : giteaAdmin
+---------------------------
+Name: keycloak-config
+Namespace: keycloak
+Data:
+  KC_DB_PASSWORD : k3-1kgxxd/X2Cw//pX-uKMsmgWogEz5YGnb5
+  KC_DB_USERNAME : keycloak
+  KEYCLOAK_ADMIN_PASSWORD : zMSjv5eA0l/+0-MDAaaNe+rHRMrB2q0NssP-
+  POSTGRES_DB : keycloak
+  POSTGRES_PASSWORD : k3-1kgxxd/X2Cw//pX-uKMsmgWogEz5YGnb5
+  POSTGRES_USER : keycloak
+  USER_PASSWORD : Kd+0+/BqPRAvnLPZO-L2o/6DoBrzUeMsr29U
+stl@ubuntu-vpn:~/git/mms/idp-temporary/basicdeployment$ GIT_SSL_NO_VERIFY=true git push
+Username for 'https://cnoe.localtest.me:8443': giteaAdmin
+Password for 'https://giteaAdmin@cnoe.localtest.me:8443':
+Enumerating objects: 5, done.
+Counting objects: 100% (5/5), done.
+Delta compression using up to 8 threads
+Compressing objects: 100% (3/3), done.
+Writing objects: 100% (3/3), 382 bytes | 382.00 KiB/s, done.
+Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
+remote: . Processing 1 references
+remote: Processed 1 references in total
+To https://cnoe.localtest.me:8443/gitea/giteaAdmin/basicdeployment.git
+   69244d6..1269617  main -> main
+```
+
+#### Wait for gitops magic: deployment into the 'production' cluster
+
+Next wait a bit until Gitops does its magic and our 'wanted' state in the repo gets automatically deployed to the 'production' cluster:
+
+![alt text](image-14.png)
+
+![alt text](image-15.png)
+
+{{% pageinfo color="info" %}}
+### What comes next?
+
+The showtime of CNOE high level behaviour and usage scenarios is now finished. We setup an initial IDP and used a backstage golden path to init and deploy a simple application.
+
+[Last not least](../conclusio/) we want to sum up the whole way from Devops to 'Frameworking' (is this the correct wording???) 
+{{% /pageinfo %}}

docs/technical-documentation/project/conceptual-onboarding/7_conclusio/README.md

@@ -0,0 +1,18 @@
+// how to create/export c4 images:
+// see also https://likec4.dev/tooling/cli/
+
+docker run -it --rm --name likec4 --user node -v $PWD:/app node bash
+npm install likec4
+exit
+
+docker commit likec4 likec4
+docker run -it --rm --user node -v $PWD:/app -p 5173:5173 likec4 bash
+
+// as root
+npx playwright install-deps 
+npx playwright install
+
+npm install likec4
+
+// render
+node@e20899c8046f:/app/content/en/docs/project/onboarding$ ./node_modules/.bin/likec4 export png -o ./images .

docs/technical-documentation/project/conceptual-onboarding/7_conclusio/_index.md

@@ -0,0 +1,33 @@
+---
+title: Conclusio
+weight: 7
+description: 'Summary and final thoughts: Always challenge theses concepts, accumptions and claims!'
+---
+
+{{% pageinfo color="info" %}}
+## Summary
+
+In the project 'Edge Developer Framework' we start with DevOps, set platforms on top to automate golden paths, and finally set 'frameworks' (aka Orchestrators') on top to have declarative,automated and reconcilable platforms.
+
+{{% /pageinfo %}}
+
+
+## From Devops over Platform to Framework Engineering
+
+We come along from a quite well known, but already complex discipline called 'Platform Engineering', which is the next level devops. 
+On top of these two domains we now have 'Framework Engineering', i.e. buildung dynamic, orchestrated and reconciling platforms:
+
+| Classic Platform engineering | New: Framework Orchestration on top of Platforms | Your job: Framework Engineer  |
+| -- | -- | -- |
+| <img src="./images/layers-and-platform-engineer.png" width="200"> |<img src="./images/layers.png" width="200"> | <img src="./images/layers-and-framework-engineer.png" width="200"> |
+
+## The whole picture of engineering
+
+So always keep in mind that as as 'Framework Engineer' you 
+ * include the skills of a platform and a devops engineer, 
+ * you do Framework, Platform and Devops Engineering at the same time
+ * and your results have impact on Frameworks, Platforms and Devops tools, layers, processes.
+
+ The following diamond is illustrating this: on top is you, on the bottom is our baseline 'DevOps'
+
+<img src="./images/modern.png" width="600">

docs/technical-documentation/project/conceptual-onboarding/7_conclusio/domain-architecture.c4

@@ -0,0 +1,102 @@
+specification {
+    tag engineering
+    element domain
+    element engineer  {
+        style {
+            shape person
+        }
+    }
+}
+
+model {
+
+    engineer framework-engineer 'Framework Engineer' 'Build and maintain one platform orchestrating framework'{
+        style {
+            color: sky
+        }
+        -> framework-engineering
+        -> platform-engineer
+    }
+
+    domain framework-engineering 'Framework Engineering' 'Building and maintaining frameworks'{
+        #engineering
+        style {
+            color: sky
+        }
+        -> framework
+        -> platform-engineering
+    }
+
+    domain framework '"Framework" (IPCEI wording!)' 'A platform defining system' {
+        style {
+            color: sky
+        }
+        -> platform
+    }
+
+    engineer platform-engineer 'Platform Engineer'  {
+         style {
+            color: indigo
+        }
+        -> platform-engineering
+        -> devops-engineer
+    }
+
+    domain platform-engineering 'Platform Engineering' 'Building and maintaining platforms' {
+        #engineering
+        style {
+            color: indigo
+        }
+        -> platform
+        -> devops-engineering
+    }
+
+    domain platform 'Platform' 'A Devops defining system' {
+        style {
+            color: indigo
+        }
+        -> devops
+    }
+
+    engineer devops-engineer 'Devops Engineer'  {
+        style {
+            color: amber
+        }
+        -> devops-engineering
+    }
+
+    domain devops-engineering 'Devops Engineering' 'Building and maintaining devops means'  {
+        #engineering
+        style {
+            color: amber
+        }
+        -> devops
+    }
+    domain devops 'Devops' 'A software lifecycle enabling tool and process setup' {
+        style {
+            color: amber
+        }
+    }
+
+}
+
+views {
+    view modern {
+        title 'Modern Devops'
+        description 'Devops is abstarcted by Platforms, Platforms are abstracted by Frameworks (IPCEI wording!)'
+        include element.kind==domain, element.kind==engineer
+
+    }
+
+    view layers {
+        include devops, platform, framework
+    }
+
+    view layers-and-framework-engineer {
+        include devops, platform, framework, framework-engineering, framework-engineer
+    }
+
+    view layers-and-platform-engineer {
+        include devops, platform, platform-engineering, platform-engineer
+    }
+}

docs/technical-documentation/project/conceptual-onboarding/_index.md

@@ -0,0 +1,9 @@
+---
+title: 'Platform 101: Conceptual Onboarding '
+linktitle: Conceptual Onboarding
+weight: 20
+description: How to conceptually onboard onto the Edge Developer Framework (EDF) requirements and the designed solution
+---
+
+
+

docs/technical-documentation/project/conceptual-onboarding/storyline.md

@@ -0,0 +1,28 @@
+
+## Storyline 
+
+1. We have the 'Developer Framework'
+2. We think the solution for DF is 'Platforming' (Digital Platforms)
+    1. The next evolution after DevOps
+    2. Gartner predicts 80% of SWE companies to have platforms in 2026
+    3. Platforms have a history since roundabout 2019
+    4. CNCF has a working group which created capabilities and a maturity model
+3. Platforms evolve - nowadys there are Platform Orchestrators
+    1. Humanitec set up a Reference Architecture
+    2. There is this 'Orchestrator' thing - declaratively describe, customize and change platforms!
+4. Mapping our assumptions to solutions
+    1. CNOE is a hot candidate to help and fulfill our platform building
+    2. CNOE aims to embrace change and customization!
+5. Showtime CNOE
+
+
+## Challenges
+
+1. Don't miss to further investigate and truely understand **DF needs**
+2. Don't miss to further investigate and truely understand **Platform capabilities**
+3. Don't miss to further investigate and truely understand **Platform orchestration**
+3. Don't miss to further investigate and truely understand **CNOE solution**
+
+## Architecture
+
+

docs/technical-documentation/project/intro-stakeholder-workshop/_index.md

@@ -0,0 +1,95 @@
+---
+title: Stakeholder Workshop Intro
+weight: 50
+description: An overall eDF introduction for stakeholders
+linktitle: Stakeholder Workshops
+---
+
+
+## Edge Developer Framework Solution Overview
+
+> This section is derived from [conceptual-onboarding-intro](../conceptual-onboarding/1_intro/)
+
+1. As presented in the introduction: We have the ['Edge Developer Framework'](./edgel-developer-framework/). \
+    In short the mission is:
+    * Build a european edge cloud IPCEI-CIS
+    * which contains typical layers infrastructure, platform, application
+    * and on top has a new layer 'developer platform'
+    * which delivers a **cutting edge developer experience** and enables **easy deploying** of applications onto the IPCEI-CIS
+2. We think the solution for EDF is in relation to ['Platforming' (Digital Platforms)](../conceptual-onboarding/3_platforming/)
+    1. The next evolution after DevOps
+    2. Gartner predicts 80% of SWE companies to have platforms in 2026
+    3. Platforms have a history since roundabout 2019
+    4. CNCF has a working group which created capabilities and a maturity model
+3. Platforms evolve - nowadys there are [Platform Orchestrators](../conceptual-onboarding/4_orchestrators/)
+    1. Humanitec set up a Reference Architecture
+    2. There is this 'Orchestrator' thing - declaratively describe, customize and change platforms!
+4. Mapping our assumptions to the [CNOE solution](../conceptual-onboarding/5_cnoe/)
+    1. CNOE is a hot candidate to help and fulfill our platform building
+    2. CNOE aims to embrace change and customization!
+
+
+## 2. Platforming as the result of DevOps
+
+### DevOps since 2010
+
+![alt text](DevOps-Lifecycle.jpg)
+
+* from 'left' to 'right' - plan to monitor
+* 'leftshift' 
+* --> turns out to be a right shift for developers with cognitive overload
+* 'DevOps isd dead' -> we need Platforms
+
+### Platforming to provide 'golden paths'
+
+> don't mix up 'golden paths' with pipelines or CI/CD
+
+![alt text](../conceptual-onboarding/3_platforming/humanitec-history.png)
+
+#### Short list of platform using companies
+
+As [Gartner states](https://www.gartner.com/en/newsroom/press-releases/2023-11-28-gartner-hype-cycle-shows-ai-practices-and-platform-engineering-will-reach-mainstream-adoption-in-software-engineering-in-two-to-five-years): "By 2026, 80% of software engineering organizations will establish platform teams as internal providers of reusable services, components and tools for application delivery."
+
+Here is a small list of companies alrteady using IDPs:
+
+* Spotify
+* Airbnb
+* Zalando
+* Uber
+* Netflix
+* Salesforce
+* Google
+* Booking.com
+* Amazon
+* Autodesk
+* Adobe
+* Cisco
+*  ...
+
+## 3 Platform building by 'Orchestrating'
+
+So the goal of platforming is to build a 'digital platform' which fits [this architecture](https://www.gartner.com/en/infrastructure-and-it-operations-leaders/topics/platform-engineering) ([Ref. in German)](https://www.gartner.de/de/artikel/was-ist-platform-engineering):
+
+![alt text](image.png)
+
+### Digital Platform blue print: Reference Architecture
+
+The blue print for such a platform is given by the reference architecture from Humanitec:
+
+[Platform Orchestrators](../conceptual-onboarding/4_orchestrators/)
+
+### Digital Platform builder: CNOE
+
+Since 2023 this is done by 'orchestrating' such platforms. One orchestrator is the [CNOE solution](../conceptual-onboarding/5_cnoe/), which highly inspired our approach.
+
+In our orchestartion engine we think in 'stacks' of 'packages' containing platform components.
+
+
+## 4 Sticking all together: Our current platform orchestrating generated platform
+
+Sticking together the platforming orchestration concept, the reference architecture and the CNOE stack solution, [this is our current running platform minimum viable product](../plan-in-2024/image-2024-8-14_10-50-27.png).
+
+This will now be presented! Enjoy!
+
+
+

docs/technical-documentation/project/plan-in-2024/_index.md

@@ -0,0 +1,45 @@
+---
+title: Plan in 2024
+weight: 30
+description: The planned project workload in 2024
+---
+
+
+## First Blue Print in 2024 
+
+Our first architectural blue print for the IPCEI-CIS Developer Framework derives from Humanitecs Reference Architecture, see links in [Blog](../../blog/240823-archsession.md)
+
+![alt text](image-2024-8-14_10-50-27.png)
+
+## C4 Model
+
+> (sources see in ./ressources/architecture-c4)
+
+> How to use: install C4lite VSC exension and/or C4lite cli - then open *.c4 files in ./ressources/architecture-c4
+
+First system landscape C4 model:
+
+![c4-model](./planes.png)
+
+## In Confluence
+
+https://confluence.telekom-mms.com/display/IPCEICIS/Architecture
+
+
+## Dimensionierung Cloud für initiales DevFramework
+
+### 28.08.24, Stefan Bethke, Florian Fürstenberg, Stephan Lo
+
+1) zuerst viele DevFrameworkPlatformEngineers arbeiten lokal, mit zentralem Deployment nach OTC in **einen/max zwei** Control-Cluster
+2) wir gehen anfangs von ca. 5 clustern aus
+3) jeder cluster mit 3 Knoten/VM (in drei AvailabilityZones)
+4) pro VM 4 CPU, 16 GB Ram, 50 GB Storage read/write once, PVCs 'ohne limit'
+5) public IPs, plus Loadbalancer
+6) Keycloak vorhanden
+7) Wildcard Domain ?? --> Eher ja
+
+Next Steps: (Vorschlag: in den nächsten 2 Wochen)
+1. Florian spezifiziert an Tobias
+2. Tobias stellt bereit, kubeconfig kommt an uns
+3. wir deployen
+

docs/technical-documentation/project/plan-in-2024/poc/_index.md

@@ -0,0 +1,15 @@
+---
+title: PoC Structure
+weight: 5
+description: Building plan of the PoC milestone (end 2024) output
+---
+
+Presented and approved on tuesday, 26.11.2024 within the team:
+
+![alt text](./_assets/image.png)
+
+
+The use cases/application lifecycle and deployment flow is drawn here: https://confluence.telekom-mms.com/display/IPCEICIS/Proof+of+Concept+2024
+
+
+![alt text](./_assets/image-1.png)

docs/technical-documentation/project/plan-in-2024/streams/_index.md

@@ -0,0 +1,52 @@
+---
+title: Workstreams
+weight: 2
+---
+
+This page is WiP (23.8.2024). 
+
+> Continued discussion on 29th Aug 24
+> * idea: Top down mit SAFe, Value Streams
+> * paralell dazu bottom up (die zB aus den technisch/operativen Tätigkeietn entstehen)
+> * Scrum Master?
+> * Claim: Self Service im Onboarding (BTW, genau das Versprechen vom Developer Framework)
+> * Org-Struktur: Scrum of Scrum (?), max. 8,9 Menschen
+
+Stefan and Stephan try to solve the mission 'wir wollen losmachen'.
+
+**Solution Idea**: 
+
+1. First we define a **rough overall structure (see 'streams')** and propose some initial **activities** (like user stories) within them.
+1. Next we work in **iterative steps** and produce iteratively progress and knowledge and outcomes in these activities.
+1. Next the **whole team** decides which are the next valuable steps
+
+## Overall Structure: Streams
+
+We discovered three **streams** in the first project steps (see also [blog](../../../blog/news/240823-archsession/_index.md)):
+
+1. Research, Fundamentals, Architecture
+1. POCs (Applications, Platform-variants, ...)
+1. Deployment, production-lifecycle
+
+```markmap
+# 
+## Stream 'Fundamentals'
+### [Platform-Definition](./fundamentals/platform-definition/)
+### [CI/CD Definition](./fundamentals/cicd-definition/)
+## Stream 'POC'
+### [CNOE](./pocs/cnoe/)
+### [Kratix](./pocs/kratix/)
+### [SIA Asset](./pocs/sia-asset/)
+### Backstage
+### Telemetry
+## Stream 'Deployment'
+### [Forgejo](./deployment/forgejo/)
+```
+
+## DoR - Definition of Ready
+
+Bevor eine Aufgabe umgesetzt wird, muss ein Design vorhanden sein.
+
+Bezüglich der 'Bebauung' von Plaztform-Komponenten gilt für das Design:
+
+1) Die Zielstellung der Komponenet muss erfasst sein

docs/technical-documentation/project/plan-in-2024/streams/deployment/_index.md

@@ -0,0 +1,14 @@
+---
+title: Deployment
+weight: 3
+---
+
+> **Mantra**: 
+> 1. Everything as Code. 
+> 1. Cloud natively deployable everywhere. 
+> 1. Ramping up and tearing down oftenly is a no-brainer. 
+> 1. Especially locally (whereby 'locally' means 'under my own control')
+
+## Entwurf (28.8.24)
+
+![Deployment 2024](./deployment.drawio.png)

docs/technical-documentation/project/plan-in-2024/streams/deployment/forgejo/_index.md

@@ -0,0 +1,36 @@
+---
+title: Activity 'Forgejo'
+linkTitle: Forgejo
+weight: 1
+---
+
+> **WiP** Ich (Stephan) schreibe mal schnell einige Stichworte, was ich so von Stefan gehört habe: 
+
+## Summary
+
+tbd
+
+## Rationale
+
+* ...
+* Design: Deployment Architecture (Platform Code vs. Application Code)
+* Design: Integration in Developer Workflow
+* ...
+
+## Task
+
+* ...
+* Runner
+* Tenants
+* User Management
+* ...
+* tbc
+
+
+## Issues
+
+### 28.08.24, Forgejo in OTC (Planung Stefan, Florian, Stephan)
+
+* STBE deployed mit Helm in bereitgestelltes OTC-Kubernetes
+* erstmal interne User Datenbank nutzen
+* dann ggf. OIDC mit vorhandenem Keycloak in der OTC anbinden

docs/technical-documentation/project/plan-in-2024/streams/fundamentals/_index.md

@@ -0,0 +1,18 @@
+---
+title: Fundamentals
+weight: 1
+---
+
+## References
+
+### Fowler / Thoughtworks
+
+* https://martinfowler.com/articles/talk-about-platforms.html
+
+* https://www.thoughtworks.com/what-we-do/platforms/digital-platform-strategy
+
+![alt text](image.png)
+
+### nice article about platform orchestration automation (introducing BACK stack)
+
+* https://dev.to/thenjdevopsguy/creating-your-platform-engineering-environment-4hpa

docs/technical-documentation/project/plan-in-2024/streams/fundamentals/cicd-definition/_index.md

@@ -0,0 +1,30 @@
+---
+title: Activity 'CI/CD Definition'
+linkTite: CI/CD Definition
+weight: 2
+---
+
+## Summary
+
+Der Produktionsprozess für Applikationen soll im Kontext von Gitops und Plattformen entworfen und mit einigen Workflowsystemen im Leerlauf implementiert werden.
+
+## Rationale
+
+In Gitops basierten Plattformen (Anm.: wie es zB. CNOE und Humanitec mit ArgoCD sind) trifft das klassische Verständnis von Pipelining mit finalem Pushing des fertigen Builds auf die Target-Plattform nicht mehr zu.
+
+D.h. in diesem fall is Argo CD = Continuous Delivery = Pulling des desired state auf die Target plattform. Eine pipeline hat hier keien Rechte mehr, single source of truth ist das 'Control-Git'. 
+
+D.h. es stellen sich zwei Fragen:
+1. Wie sieht der adaptierte Workflow aus, der die 'Single Source of Truth' im 'Control-Git' definiert? Was ist das gewünschte korrekte Wording? Was bedeuen CI und CD in diesem (neuen) Kontext ? Auf welchen Environmants laufen Steps (zB Funktionstest), die eben nicht mehr auf einer gitops-kontrollierten Stage laufen?
+2. Wie sieht der Workflow aus für 'Events', die nach dem CI/CD in die single source of truth einfliessen? ZB. abnahmen auf einer Abnahme Stage, oder Integrationsprobleme auf einer test Stage  
+
+## Task
+
+* Es sollen existierende, typische Pipelines hergenommen werden und auf die oben skizzierten Fragestellungen hin untersucht und angepasst werden.
+* In lokalen Demo-Systemen (mit oder ohne CNOE aufgesetzt) sollen die Pipeline entwürfe dummyhaft dargestellt werden und luffähig sein.
+* Für den POC sollen Workflow-Systeme wie Dagger, Argo Workflow, Flux, Forgejo Actions zum Einsatz kommen. 
+
+
+## Further ideas for POSs
+
+* see sample flows in https://docs.kubefirst.io/

docs/technical-documentation/project/plan-in-2024/streams/fundamentals/platform-definition/_index.md

@@ -0,0 +1,30 @@
+---
+title: Activity 'Platform Definition'
+linkTitle: Platform Definition
+weight: 1
+---
+
+## Summary 
+
+Das theoretische Fundament unserer Plattform-Architektur soll begründet und weitere wesentliche Erfahrungen anderer Player durch Recherche erhoben werden, so dass unser aktuelles Zielbild abgesichert ist. 
+
+## Rationale
+
+Wir starten gerade auf der Bais des Referenzmodells zu Platform-Engineering von Gartner und Huamitec. 
+Es gibt viele weitere Grundlagen und Entwicklungen zu Platform Engineering. 
+
+## Task
+
+* Zusammentragen, wer was federführend macht in der Plattform Domäne, vgl. auch Linkliste im [Blog](../../../../../blog/240823-archsession.md)
+* Welche trendsettenden Plattformen gibt es?
+* Beschreiben der Referenzarchitektur in unserem Sinn
+* Begriffsbildung, Glossar erstellen (zB Stacks oder Ressource-Bundles)
+* Architekturen erstellen mit Control Planes, Seedern, Targets, etc. die mal zusammenliegen, mal nicht
+* Beschreibung der Wirkungsweise der Platform-Orchestration (Score, Kubevela, DSL, ... und Controlern hierzu) in verscheidenen Platform-Implemnetierungen
+* Ableiten, wie sich daraus unser Zielbild und Strategie ergeben.
+* Argumentation für unseren Weg zusammentragen.
+* Best Practices und wichtige Tipps und Erfahrungen zusammentragen.
+
+
+
+

docs/technical-documentation/project/plan-in-2024/streams/pocs/_index.md

@@ -0,0 +1,8 @@
+---
+title: POCs
+weight: 2
+---
+
+## Further ideas for POSs
+
+* see sample apps 'metaphor' in https://docs.kubefirst.io/

docs/technical-documentation/project/plan-in-2024/streams/pocs/cnoe/_index.md

@@ -0,0 +1,32 @@
+---
+title: Activity 'CNOE Investigation'
+linkTitle: CNOE
+weight: 1
+---
+
+
+## Summary
+
+Als designiertes Basis-Tool des Developer Frameworks sollen die Verwendung und die Möglichkeiten von CNOE zur Erweiterung analysiert werden.
+
+## Rationale
+
+CNOE ist das designierte Werkzeug zur Beschreibung und Ausspielung des Developer Frameworks. 
+Dieses Werkzeug gilt es zu erlernen, zu beschreiben und weiterzuentwickeln.
+Insbesondere der Metacharkter des 'Software zur Bereitstellung von Bereitstellungssoftware für Software', d.h. der unterschiedlichen Ebenen für unterschiedliche Use Cases und Akteure soll klar verständlich und dokumentiert werden. Siehe hierzu auch das Webinar von Huamnitec und die Diskussion zu unterschiedlichen Bereitstellungsmethoden eines RedisCaches.
+
+## Task
+
+* CNOE deklarativ in lokalem und ggf. vorhandenem Cloud-Umfeld startbar machen
+* Architektur von COE beschreiben, wesentliche Wording finden (zB Orchestrator, Stacks, Kompoennten-Deklaration, ...)
+* Tests / validations durchführen
+* eigene 'Stacks erstellen' (auch in Zusammenarbeit mit Applikations-POCs, zB. SIA und Telemetrie)
+* Wording und Architektur von Activity ['Platform-Definition'](../../fundamentals/platform-definition/) beachten und challengen
+* Alles, was startbar und lauffähig ist, soll möglichst vollautomatisch verscriptet und git dokumentiert in einem Repo liegen
+
+## Issues / Ideas / Improvements
+
+* k3d anstatt kind
+* kind: ggf. issue mit kindnet, ersetzen durch Cilium
+
+

docs/technical-documentation/project/plan-in-2024/streams/pocs/kratix/_index.md

@@ -0,0 +1,19 @@
+---
+title: Activity 'Kratix Investigation'
+linkTitle: Kratix
+weight: 3
+---
+
+
+## Summary
+
+Ist [Kratix](https://www.kratix.io/) eine valide Alternative zu CNOE?
+
+## Rationale
+
+
+## Task
+
+
+## Issues / Ideas / Improvements
+

docs/technical-documentation/project/plan-in-2024/streams/pocs/sia-asset/_index.md

@@ -0,0 +1,50 @@
+---
+title: Activity 'SIA Asset Golden Path Development'
+linkTitle: SIA Asset
+weight: 2
+---
+
+## Summary
+
+Implementierung eines Golden Paths in einem CNOE/Backstage Stack für das existierende 'Composable SIA (Semasuite Integrator Asset)'.
+
+## Rationale
+
+Das SIA Asset ist eine Entwicklung des PC DC - es ist eine Composable Application die einen OnlineShop um die Möglichkeit der FAX-Bestellung erweitert.
+Die Entwicklung begann im Januar 2024 mit einem Team von drei Menschen, davon zwei Nearshore, und hatte die typischen ersten Stufen - erst Applikationscode ohne Integration, dann lokale gemockte Integration, dann lokale echte Integration, dann Integration auf einer Integrationsumgebung, dann Produktion. Jedesmal bei Erklimmung der nächsten Stufe mit Erstellung von individuellem Build und Deploymentcode und Abwägungen, wie aufwändig nachhaltig und wie benutzbar das jeweilige Konstrukt sein sollte.
+Ein CI/CD gibt es nicht, zu großer Aufwand für so ein kleines Projekt.
+
+Die Erwartung ist, dass so ein Projekt als 'Golden Path' abbildbar ist und die Entwicklung enorm bescheunigt.
+
+## Task
+
+* SIA 'auf die Platform heben' (was immer das bedeutet)
+* Den Build-Code von SIA (die Applikation und einen Shop) in einen CI/CD Workflow transformieren
+
+
+## References
+
+* https://platformengineering.org/blog/decoding-golden-paths-the-highway-for-your-developers
+
+
+## Scenario (see IPCEICIS-363)
+
+```mermaid
+graph TB
+  Developer[fa:fa-user developer]
+  PlatformDeliveryAndControlPlaneIDE[IDE]
+  subgraph LocalBox["localBox"]
+    LocalBox.EDF[Platform]
+    LocalBox.Local[local]
+  end
+  subgraph CloudGroup["cloudGroup"]
+    CloudGroup.Test[test]
+    CloudGroup.Prod[prod]
+  end
+  Developer -. "use preferred IDE as local code editing, building, testing, syncing tool" .-> PlatformDeliveryAndControlPlaneIDE
+  Developer -. "manage (in Developer Portal)" .-> LocalBox.EDF
+  PlatformDeliveryAndControlPlaneIDE -. "provide "code"" .-> LocalBox.EDF
+  LocalBox.EDF -. "provision" .-> LocalBox.Local
+  LocalBox.EDF -. "provision" .-> CloudGroup.Prod
+  LocalBox.EDF -. "provision" .-> CloudGroup.Test
+```

docs/technical-documentation/project/team-process/_index.md

@@ -0,0 +1,139 @@
+---
+title: Team and Work Structure 
+weight: 50
+description: The way we work and produce runnable, presentable software
+linkTitle: Team-Process
+---
+
+This document describes a proposal to set up a team work structure to primarily get the POC successfully delivered. Later on we will adjust and refine the process to fit for the MVP.
+
+## Introduction
+
+### Rationale
+
+We currently face the following [challenges in our process](https://confluence.telekom-mms.com/display/IPCEICIS/Proof+of+Concept+2024):
+
+1. missing team alignment on PoC-Output over all components
+    1. Action: team is committed to **clearly defined PoC capabilities**
+    1. Action: every each team-member is aware of **individual and common work** to be done (backlog) to achieve PoC
+1. missing concept for repository (process, structure, 
+    1. Action: the **PoC has a robust repository concept** up & running
+    1. Action: repo concept is applicable for other repositorys as well (esp. documentation repo)
+
+### General working context
+
+A **project goal** drives us as a **team** to create valuable **product output**. 
+
+The **backlog** contains the product specification which instructs us by working in **tasks** with the help and usage of **ressources** (like git, 3rd party code and knowledge and so on).
+
+![alt text](./_assets/P1.png)
+
+Goal, Backlog, Tasks and Output must be in a well-defined context, such that the team can be productive.
+
+### POC and MVP working context
+
+This document has two targets: POC and MVP.
+
+Today is mid november 2024 and we need to package our project results created since july 2024 to deliver the POC product.
+
+![alt text](./_assets/P2.png)
+
+> Think of the agenda's goal like this: Imagine Ralf the big sponsor passes by and sees 'edge Developer Framework' somewhere on your screen. Then he asks: 'Hey cool, you are one of these famous platform guys?! I always wanted to get a demo how this framework looks like!' \
+> **What are you going to show him?**
+
+## Team and Work Structure (POC first, MVP later)
+
+In the following we will look at the work structure proposal, primarily for the POC, but reusable for any other release or the MVP
+
+### Consolidated POC (or any release later)
+
+![alt text](./_assets/P3.png)
+
+#### Responsibilities to reliably specify the deliverables
+
+![alt text](./_assets/P4.png)
+
+#### Todos
+
+1. SHOULD: Clarify context (arch, team, leads)
+1. MUST: Define Deliverables (arch, team) (Hint: Deleiverables could be seen 1:1 as use cases - not sure about that right now)
+1. MUST: Define Output structure (arch, leads)
+
+### Process (General): from deliverables to output (POC first, MVP later)
+
+Most important in the process are:
+
+* **traces** from tickets to outputs (as the clue to understand and control what is where)
+* **README.md** (as the clue how to use the output)
+
+![alt text](./_assets/P5.png)
+
+### Output Structure POC
+
+Most important in the POC structure are:
+
+* one repo which is the product
+* a README which maps project goals to the repo content
+* the content consists of capabilities
+* capabilities are shown ('prooven') by use cases
+* the use cases are described in the deliverables
+
+![alt text](./_assets/P6.png)
+
+#### Glossary
+
+* README: user manual and storybook
+* Outcome: like resolution, but more verbose and detailled (especially when resolution was 'Done'), so that state changes are easily recognisable
+
+### Work Structure Guidelines (POC first, MVP later)
+
+#### Structure
+
+1. each task and/or user story has at least a branch in an existing repo or a new, dedicated task repo
+    > recommended: multi-repo over monorepo
+1. each repo has a main and development branch. development is the intgration line
+1. pull requests are used to merge work outputs to the integration line
+1. optional (my be too cumbersome): each PR should be reflected as comment in jira
+
+#### Workflow (in any task / user story)
+
+1. when output comes in own repo: `git init` --> always create as fast as possible a new repo
+1. commit early and oftenly
+1. comments on output and outcome when where is new work done. this could typically correlate to a pull request, see above
+
+#### Definition of Done
+
+1. Jira: there is a final comment summarizimg the outcome (in a bit more verbose from than just the 'resolution' of the ticket) and the main outputs. This may typically be a link to the commit and/or pull request of the final repo state
+2. Git/Repo: there is a README.md in the root of the repo. It summarizes in a typical Gihub-manner how to use the repo, so that it does what it is intended to do and reveals all the bells and whistles of the repo to the consumer. If the README doesn't lead to the usable and recognizable added value the work is not done! 
+
+#### Review
+
+1. Before a ticket gets finished (not defined yet which jira-state this is) there must be a review by a second team member
+1. the reviewing person may review whatever they want, but must at least check the README
+
+#### Out of scope (for now)
+
+The following topics are optional and do not need an agreement at the moment:
+
+1. Commit message syntax
+    > Recommendation: at least 'WiP' would be good if the state is experimental
+1. branch permissions
+1. branch clean up policies
+1. squashing when merging into the integration line
+1. CI
+1. Tech blogs / gists
+1. Changelogs
+
+#### Integration of Jira with Forgejo (compare to https://github.com/atlassian/github-for-jira)
+
+1. Jira -> Forgejo: Create Branch
+1. Forgejo -> Jira:
+    1. commit
+    2. PR
+
+## Status of POC Capabilities
+
+The following table lists an analysis of the status of the ['Funcionality validation' of the POC](https://confluence.telekom-mms.com/display/IPCEICIS/Proof+of+Concept+2024). 
+Assumption: These functionalities should be the aforementioned capabilities.
+
+![alt text](./_assets/P8.png)

docs/technical-documentation/solution/_index.md

@@ -0,0 +1,6 @@
+---
+title: Solution
+weight: 2
+description: "The implemented platforming solutions of EDF, i.e. the solution domain. The documentation of all project output: Design, Building blocks, results, show cases, artifacts and so on"
+---
+

docs/technical-documentation/solution/design/_index.md

@@ -0,0 +1,7 @@
+---
+title: Design
+weight: 1
+description: Edge Developver Framework Design Documents
+---
+
+This design documentation structure is inspired by the [design of crossplane](https://github.com/crossplane/crossplane/tree/main/design#readme).

docs/technical-documentation/solution/design/decision-iam-and-edf-self-containment.md

@@ -0,0 +1,31 @@
+---
+title: eDF is self-contained and has an own IAM (WiP)
+weight: 2
+description: tbd
+---
+
+* Type: Proposal
+* Owner: Stephan Lo (stephan.lo@telekom.de)
+* Reviewers: EDF Architects
+* Status: Speculative, revision 0.1
+
+## Background
+
+tbd
+
+## Proposal
+
+==== 1 =====
+
+There is a core eDF which is self-contained and does not have any impelmented dependency to external platforms.
+eDF depends on abstractions.
+Each embdding into customer infrastructure works with adapters which implement the abstraction.
+
+==== 2 =====
+
+eDF has an own IAM. This may either hold the principals and permissions itself when there is no other IAM or proxy and map them when integrated into external enterprise IAMs.
+
+
+## Reference 
+
+Arch call from 4.12.24, Florian, Stefan, Stephan-Pierre  

docs/technical-documentation/solution/design/proposal-local-deployment.md

@@ -0,0 +1,23 @@
+---
+title: Agnostic EDF Deployment
+weight: 2
+description: The implementation of EDF must be kubernetes provider agnostic
+---
+
+* Type: Proposal
+* Owner: Stephan Lo (stephan.lo@telekom.de)
+* Reviewers: EDF Architects
+* Status: Speculative, revision 0.1
+
+## Background
+
+EDF is running as a controlplane - or let's say an orchestration plane, correct wording is still to be defined - in a kubernetes cluster.
+Right now we have at least ArgoCD as controller of manifests which we provide as CNOE stacks of packages and standalone packages.
+
+## Proposal
+
+The implementation of EDF must be kubernetes provider agnostic. Thus each provider specific deployment dependency must be factored out into provider specific definitions or deployment procedures.
+
+## Local deployment
+
+This implies that EDF must always be deployable into a local cluster, whereby by 'local' we mean a cluster which is under the full control of the platform engineer, e.g. a kind cluster on their laptop.

docs/technical-documentation/solution/design/proposal-stack-hydration.md

@@ -0,0 +1,28 @@
+---
+title: Agnostic Stack Definition
+weight: 2
+description: The implementation of EDF stacks must be kubernetes provider agnostic by a templating/hydration mechanism
+---
+
+* Type: Proposal
+* Owner: Stephan Lo (stephan.lo@telekom.de)
+* Reviewers: EDF Architects
+* Status: Speculative, revision 0.1
+
+## Background
+
+When booting and reconciling the 'final' stack exectuting orchestrator (here: ArgoCD) needs to get rendered (or hydrated) presentations of the manifests. 
+
+It is not possible or unwanted that the orchestrator itself resolves dependencies or configuration values.
+
+## Proposal
+
+The hydration takes place for all target clouds/kubernetes providers. There is no 'default' or 'special' setup, like the Kind version.
+
+## Local development
+
+This implies that in a development process there needs to be a build step hydrating the ArgoCD manifests for the targeted cloud.
+
+## Reference 
+
+Discussion from Robert and Stephan-Pierre in the context of stack development - there should be an easy way to have locally changed stacks propagated into the local running platform.   

docs/technical-documentation/solution/scenarios/_index.md

@@ -0,0 +1,6 @@
+---
+title: Scenarios
+weight: 1
+description: Usage scenarios and system architecture
+---
+

docs/technical-documentation/solution/scenarios/gitops/_index.md

@@ -0,0 +1,16 @@
+---
+title: Gitops
+weight: 1
+description: Gitops scenarios
+---
+
+WiP - this is in work.
+
+What kind of Gitops do we have with idpbuilder/CNOE ?
+
+## References
+
+
+https://github.com/gitops-bridge-dev/gitops-bridge
+
+![alt text](image.png)

docs/technical-documentation/solution/scenarios/orchestration/_index.md

@@ -0,0 +1,34 @@
+---
+title: Orchestration
+weight: 1
+description: Usage scenarios and system architecture of platform orchestartion
+---
+
+WiP - this is in work.
+
+What deployment scenarios do we have with idpbuilder/CNOE ?
+
+## References
+
+* Base Url of CNOE presentations: https://github.com/cnoe-io/presentations/tree/main
+
+### CNOE in EKS
+
+The next chart shows a system landscape of CNOE orchestration.
+
+[2024-04-PlatformEngineering-DevOpsDayRaleigh.pdf](https://github.com/cnoe-io/presentations/blob/main/2024-04-PlatformEngineering-DevOpsDayRaleigh.pdf)
+
+Questions: What are the degrees of freedom in this chart? What variations with respect to environments and environmnent types exist? 
+
+![alt text](image.png)
+
+### CNOE in AWS
+
+The next chart shows a context chart of CNOE orchestration.
+
+[reference-implementation-aws](https://github.com/cnoe-io/reference-implementation-aws)
+
+Questions: What are the degrees of freedom in this chart? What variations with respect to environments and environmnent types exist? 
+
+
+![alt text](image-1.png)

docs/technical-documentation/solution/tools/Backstage/Backstage setup tutorial/_index.md

@@ -0,0 +1,60 @@
++++
+title = "Backstage Local Setup Tutorial"
+weight = 4
++++
+
+This document provides a comprehensive guide on the prerequisites and the process to set up and run Backstage locally on your machine.
+
+## Table of Contents
+
+1. [Prerequisites](#prerequisites)
+2. [Setting Up Backstage](#setting-up-backstage)
+3. [Run the Backstage Application](#run-the-backstage-application)
+
+## Prerequisites
+
+Before you start, make sure you have the following installed on your machine:
+
+1. **Node.js**: Backstage requires Node.js. You can download it from the [Node.js website](https://nodejs.org/). It is recommended to use the LTS version.
+
+2. **Yarn**: Backstage uses Yarn as its package manager. You can install it globally using npm:
+   ```bash
+   npm install --global yarn
+   ```
+
+3. **Git**
+4. **Docker**
+
+## Setting Up Backstage
+
+
+To install the Backstage Standalone app, you can use npx. npx is a tool that comes preinstalled with Node.js and lets you run commands straight from npm or other registries.
+
+```bash
+npx @backstage/create-app@latest
+```
+This command will create a new directory with a Backstage app inside. The wizard will ask you for the name of the app. This name will be created as sub directory in your current working directory.
+
+Below is a simplified layout of the files and folders generated when creating an app.
+```bash
+app
+├── app-config.yaml
+├── catalog-info.yaml
+├── package.json
+└── packages
+    ├── app
+    └── backend
+```
+
+- **app-config.yaml**: Main configuration file for the app. See Configuration for more information.
+- **catalog-info.yaml**: Catalog Entities descriptors. See Descriptor Format of Catalog Entities to get started.
+- **package.json**: Root package.json for the project. Note: Be sure that you don't add any npm dependencies here as they probably should be installed in the intended workspace rather than in the root.
+- **packages/**: Lerna leaf packages or "workspaces". Everything here is going to be a separate package, managed by lerna.
+- **packages/app/**: A fully functioning Backstage frontend app that acts as a good starting point for you to get to know Backstage.
+- **packages/backend/**: We include a backend that helps power features such as Authentication, Software Catalog, Software Templates, and TechDocs, amongst other things.
+
+## Run the Backstage Application
+You can run it in Backstage root directory by executing this command:
+```bash
+yarn dev
+```

docs/technical-documentation/solution/tools/Backstage/Exsisting Plugins/_index.md

@@ -0,0 +1,49 @@
++++
+title = "Existing Backstage Plugins"
+weight = 4
++++
+
+1. **Catalog**:  
+   - Used for managing services and microservices, including registration, visualization, and the ability to track dependencies and relationships between services. It serves as a central directory for all services in an organization.
+
+2. **Docs**:  
+   - Designed for creating and managing documentation, supporting formats such as Markdown. It helps teams organize and access technical and non-technical documentation in a unified interface.
+
+3. **API Docs**:  
+   - Automatically generates API documentation based on OpenAPI specifications or other API definitions, ensuring that your API information is always up to date and accessible for developers.
+
+4. **TechDocs**:  
+   - A tool for creating and publishing technical documentation. It is integrated directly into Backstage, allowing developers to host and maintain documentation alongside their projects.
+
+5. **Scaffolder**:  
+   - Allows the rapid creation of new projects based on predefined templates, making it easier to deploy services or infrastructure with consistent best practices.
+
+6. **CI/CD**:  
+   - Provides integration with CI/CD systems such as GitHub Actions and Jenkins, allowing developers to view build status, logs, and pipelines directly in Backstage.
+
+7. **Metrics**:  
+   - Offers the ability to monitor and visualize performance metrics for applications, helping teams to keep track of key indicators like response times and error rates.
+
+8. **Snyk**:  
+   - Used for dependency security analysis, scanning your codebase for vulnerabilities and helping to manage any potential security risks in third-party libraries.
+
+9. **SonarQube**:  
+   - Integrates with SonarQube to analyze code quality, providing insights into code health, including issues like technical debt, bugs, and security vulnerabilities.
+
+10. **GitHub**:  
+   - Enables integration with GitHub repositories, displaying information such as commits, pull requests, and other repository activity, making collaboration more transparent and efficient.
+
+11. **CircleCI**:  
+   - Allows seamless integration with CircleCI for managing CI/CD workflows, giving developers insight into build pipelines, test results, and deployment statuses.
+
+12. **Kubernetes**:  
+   - Provides tools to manage Kubernetes clusters, including visualizing pod status, logs, and cluster health, helping teams maintain and troubleshoot their cloud-native applications.
+
+13. **Cloud**:  
+   - Includes plugins for integration with cloud providers like AWS and Azure, allowing teams to manage cloud infrastructure, services, and billing directly from Backstage.
+
+14. **OpenTelemetry**:  
+   - Helps with monitoring distributed applications by integrating OpenTelemetry, offering powerful tools to trace requests, detect performance bottlenecks, and ensure application health.
+
+15. **Lighthouse**:  
+   - Integrates Google Lighthouse to analyze web application performance, helping teams identify areas for improvement in metrics like load times, accessibility, and SEO.

docs/technical-documentation/solution/tools/Backstage/General Information/_index.md

@@ -0,0 +1,24 @@
++++
+title = "Backstage Description"
+weight = 4
++++
+
+Backstage by Spotify can be seen as a Platform Portal. It is an open platform for building and managing internal developer tools, providing a unified interface for accessing various tools and resources within an organization.
+
+Key Features of Backstage as a Platform Portal:
+Tool Integration:
+
+Backstage allows for the integration of various tools used in the development process, such as CI/CD, version control systems, monitoring, and others, into a single interface.
+Service Management:
+
+It offers the ability to register and manage services and microservices, as well as monitor their status and performance.
+Documentation and Learning Materials:
+
+Backstage includes capabilities for storing and organizing documentation, making it easier for developers to access information.
+Golden Paths:
+
+Backstage supports the concept of "Golden Paths," enabling teams to follow recommended practices for development and tool usage.
+Modularity and Extensibility:
+
+The platform allows for the creation of plugins, enabling users to customize and extend Backstage's functionality to fit their organization's needs.
+Backstage provides developers with centralized and convenient access to essential tools and resources, making it an effective solution for supporting Platform Engineering and developing an internal platform portal.

docs/technical-documentation/solution/tools/Backstage/Plugin Creation Tutorial/_index.md

@@ -0,0 +1,169 @@
++++
+title = "Plugin Creation Tutorial"
+weight = 4
++++
+Backstage plugins and functionality extensions should be writen in TypeScript/Node.js because backstage is written in those languages
+### General Algorithm for Adding a Plugin in Backstage
+
+1. **Create the Plugin**  
+   To create a plugin in the project structure, you need to run the following command at the root of Backstage:
+
+   ```bash
+   yarn new --select plugin
+   ```
+
+   The wizard will ask you for the plugin ID, which will be its name. After that, a template for the plugin will be automatically created in the directory `plugins/{plugin id}`. After this install all needed dependencies. After this install required dependencies. In example case this is `"axios"` for API requests  
+   Emaple:
+   ```bash
+    yarn add axios
+   ```
+2. **Define the Plugin’s Functionality**  
+   In the newly created plugin directory, focus on defining the plugin's core functionality. This is where you will create components that handle the logic and user interface (UI) of the plugin. Place these components in the `plugins/{plugin_id}/src/components/` folder, and if your plugin interacts with external data or APIs, manage those interactions within these components.
+
+3. **Set Up Routes**  
+   In the main configuration file of your plugin (typically `plugins/{plugin_id}/src/routs.ts`), set up the routes. Use `createRouteRef()` to define route references, and link them to the appropriate components in your `plugins/{plugin_id}/src/components/` folder. Each route will determine which component renders for specific parts of the plugin.
+
+4. **Register the Plugin**  
+   Navigate to the `packages/app` folder and import your plugin into the main application. Register your plugin in the `routs` array within `packages/app/src/App.tsx` to integrate it into the Backstage system. It will create a rout for your's plugin page
+
+5. **Add Plugin to the Sidebar Menu**  
+   To make the plugin accessible through the Backstage sidebar, modify the sidebar component in `packages/app/src/components/Root.tsx`. Add a new sidebar item linked to your plugin’s route reference, allowing users to easily access the plugin through the menu.
+
+6. **Test the Plugin**  
+   Run the Backstage development server using `yarn dev` and navigate to your plugin’s route via the sidebar or directly through its URL. Ensure that the plugin’s functionality works as expected.
+
+### Example
+All steps will be demonstrated using a simple example plugin, which will request JSON files from the API of jsonplaceholder.typicode.com and display them on a page.
+
+1. Creating test-plugin:
+   ```bash
+   yarn new --select plugin
+   ```
+   Adding required dependencies. In this case only "axios" is needed for API requests
+   ```bass
+   yarn add axios
+   ```
+2. Implement code of the plugin component in  `plugins/{plugin-id}/src/{Component name}/{filename}.tsx`
+   ```javascript
+   import React, { useState } from 'react';
+   import axios from 'axios';
+   import { Typography, Grid } from '@material-ui/core';
+   import {
+     InfoCard,
+     Header,
+     Page,
+     Content,
+     ContentHeader,
+     SupportButton,
+   } from '@backstage/core-components';
+
+   export const TestComponent = () => {
+     const [posts, setPosts] = useState<any[]>([]);
+     const [loading, setLoading] = useState(false);
+     const [error, setError] = useState<string | null>(null);
+
+     const fetchPosts = async () => {
+       setLoading(true);
+       setError(null);
+
+       try {
+         const response = await axios.get('https://jsonplaceholder.typicode.com/posts');
+         setPosts(response.data);
+       } catch (err) {
+         setError('Ошибка при получении постов');
+       } finally {
+         setLoading(false);
+       }
+     };
+
+     return (
+       <Page themeId="tool">
+         <Header title="Welcome to the Test Plugin!" subtitle="This is a subtitle">
+           <SupportButton>A description of your plugin goes here.</SupportButton>
+         </Header>
+         <Content>
+           <ContentHeader title="Posts Section">
+             <SupportButton>
+               Click to load posts from the API.
+             </SupportButton>
+           </ContentHeader>
+           <Grid container spacing={3} direction="column">
+             <Grid item>
+               <InfoCard title="Information Card">
+                 <Typography variant="body1">
+                   This card contains information about the posts fetched from the API.
+                 </Typography>
+                 {loading && <Typography>Загрузка...</Typography>}
+                 {error && <Typography color="error">{error}</Typography>}
+                 {!loading && !posts.length && (
+                   <button onClick={fetchPosts}>Request Posts</button>
+                 )}
+               </InfoCard>
+             </Grid>
+             <Grid item>
+               {posts.length > 0 && (
+                 <InfoCard title="Fetched Posts">
+                   <ul>
+                     {posts.map(post => (
+                       <li key={post.id}>
+                       <Typography variant="h6">{post.title}</Typography>
+                       <Typography>{post.body}</Typography>
+                       </li>
+                      ))}
+                   </ul>
+                 </InfoCard>
+               )}
+             </Grid>
+           </Grid>
+         </Content>
+       </Page>
+     );
+   };
+
+   ```
+   
+3. Setup routs in plugins/{plugin_id}/src/routs.ts
+  ```javascript
+  import { createRouteRef } from '@backstage/core-plugin-api';
+
+  export const rootRouteRef = createRouteRef({
+    id: 'test-plugin',
+  });
+  ```
+
+4. Register the plugin in `packages/app/src/App.tsx` in routes
+  Import of the plugin:
+  ```javascript
+  import { TestPluginPage } from '@internal/backstage-plugin-test-plugin';
+  ```
+
+  Adding route:
+  ```javascript
+  const routes = (
+      <FlatRoutes>
+         ... //{Other Routs}
+         <Route path="/test-plugin" element={<TestPluginPage />} />
+      </FlatRoutes>
+  )
+  ```
+
+5. Add Item to sidebar menu of the backstage in `packages/app/src/components/Root/Root.tsx`. This should be added in to Root object as another SidebarItem
+  ```javascript
+  export const Root = ({ children }: PropsWithChildren<{}>) => (
+    <SidebarPage>
+      <Sidebar>
+        ... //{Other sidebar items}
+        <SidebarItem icon={ExtensionIcon} to="/test-plugin" text="Test Plugin" />
+      </Sidebar>
+      {children}
+    </SidebarPage>
+  );
+  ```
+   
+6. Plugin is ready. Run the application
+ ```bash
+  yarn dev
+ ```
+
+![example](example_1.png)
+![example](example_2.png)

docs/technical-documentation/solution/tools/Backstage/_index.md

@@ -0,0 +1,5 @@
+---
+title: Backstage
+weight: 2
+description: Here you will find information about Backstage, it's plugins and usage tutorials
+---

docs/technical-documentation/solution/tools/CNOE/CNOE-competitors/_index.md

@@ -0,0 +1,68 @@
+---
+title: Analysis of CNOE competitors
+weight: 1
+description: We compare CNOW - which we see as an orchestrator - with other platform orchestring tools like Kratix and Humanitc
+---
+
+## Kratix
+
+Kratix is a Kubernetes-native framework that helps platform engineering teams automate the provisioning and management of infrastructure and services through custom-defined abstractions called Promises. It allows teams to extend Kubernetes functionality and provide resources in a self-service manner to developers, streamlining the delivery and management of workloads across environments.
+
+### Concepts
+Key concepts of Kratix:
+- Workload:
+This is an abstraction representing any application or service that needs to be deployed within the infrastructure. It defines the requirements and dependent resources necessary to execute this task.
+- Promise:
+A "Promise" is a ready-to-use infrastructure or service package. Promises allow developers to request specific resources (such as databases, storage, or computing power) through the standard Kubernetes interface. It’s similar to an operator in Kubernetes but more universal and flexible.
+Kratix simplifies the development and delivery of applications by automating the provisioning and management of infrastructure and resources through simple Kubernetes APIs.
+
+### Pros of Kratix:
+- Resource provisioning automation. Kratix simplifies infrastructure creation for developers through the abstraction of "Promises." This means developers can simply request the necessary resources (like databases, message queues) without dealing with the intricacies of infrastructure management.
+
+- Flexibility and adaptability. Platform teams can customize and adapt Kratix to specific needs by creating custom Promises for various services, allowing the infrastructure to meet the specific requirements of the organization.
+
+- Unified resource request interface. Developers can use a single API (Kubernetes) to request resources, simplifying interaction with infrastructure and reducing complexity when working with different tools and systems.
+
+### Cons of Kratix:
+- Although Kratix offers great flexibility, it can also lead to more complex setup and platform management processes. Creating custom Promises and configuring their behavior requires time and effort.
+
+- Kubernetes dependency. Kratix relies on Kubernetes, which makes it less applicable in environments that don’t use Kubernetes or containerization technologies. It might also lead to integration challenges if an organization uses other solutions.
+
+- Limited ecosystem. Kratix doesn’t have as mature an ecosystem as some other infrastructure management solutions (e.g., Terraform, Pulumi). This may limit the availability of ready-made solutions and tools, increasing the amount of manual work when implementing Kratix.
+
+
+## Humanitec
+
+Humanitec is an Internal Developer Platform (IDP) that helps platform engineering teams automate the provisioning 
+and management of infrastructure and services through dynamic configuration and environment management. 
+
+It allows teams to extend their infrastructure capabilities and provide resources in a self-service manner to developers, streamlining the deployment and management of workloads across various environments.
+
+### Concepts
+Key concepts of Humanitec:
+- Application Definition:  
+  This is an abstraction where developers define their application, including its services, environments, a dependencies. It abstracts away infrastructure details, allowing developers to focus on building and deploying their applications.
+
+- Dynamic Configuration Management:  
+  Humanitec automatically manages the configuration of applications and services across multiple environments (e.g., development, staging, production). It ensures consistency and alignment of configurations as applications move through different stages of deployment.
+
+Humanitec simplifies the development and delivery process by providing self-service deployment options while maintaining 
+centralized governance and control for platform teams.
+
+### Pros of Humanitec:
+- Resource provisioning automation. Humanitec automates infrastructure and environment provisioning, allowing developers to focus on building and deploying applications without worrying about manual configuration.
+
+- Dynamic environment management. Humanitec manages application configurations across different environments, ensuring consistency and reducing manual configuration errors.
+
+- Golden Paths. best-practice workflows and processes that guide developers through infrastructure provisioning and application deployment. This ensures consistency and reduces cognitive load by providing a set of recommended practices.
+
+- Unified resource management interface. Developers can use Humanitec’s interface to request resources and deploy applications, reducing complexity and improving the development workflow.
+
+### Cons of Humanitec:
+- Humanitec is commercially licensed software
+
+- Integration challenges. Humanitec’s dependency on specific cloud-native environments can create challenges for organizations with diverse infrastructures or those using legacy systems.
+
+- Cost. Depending on usage, Humanitec might introduce additional costs related to the implementation of an Internal Developer Platform, especially for smaller teams.
+
+- Harder to customise