PLT-1074 - Switch to other technology

* build only on master
* update README.md to reflect latest changes
* remove useless ```

Author: Engerim

.github/workflows/pages.yml

@@ -4,7 +4,7 @@ on:
   pull_request:
   push:
     branches:
-      #- master
+      - master
 
 permissions:
   contents: read
@@ -29,7 +29,7 @@ jobs:
       - name: Setup Pages ⚙️
         id: pages
         uses: actions/configure-pages@v4
-        #if: ${{ github.ref == 'refs/heads/master' }}
+        if: ${{ github.ref == 'refs/heads/master' }}
         with:
           static_site_generator: next
 
@@ -42,6 +42,7 @@ jobs:
           path: ./build
 
   deploy:
+    if: ${{ github.ref == 'refs/heads/master' }}
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}

README.md

@@ -1,106 +1,82 @@
-# Motivation
+# Flaconi Technology Radar 
+This Tech Radar is built by using the [AOE Technology Radar](https://github.com/AOEpeople/aoe_technology_radar), which contains the skeleton app.
 
-At [Flaconi](http://flaconi.de), we maintain a [public Tech
-Radar](http://flaconi.github.io/tech-radar/) to help our engineering teams
-align on technology choices. It is based on the [pioneering work
-by ThoughtWorks](https://www.thoughtworks.com/radar) and [zalando](https://zalando.github.io/tech-radar).
+## Contribute to the Technical Radar
 
-This repository contains the code to generate the visualization:
-[`radar.js`](/docs/radar.js) (based on [d3.js v4](https://d3js.org)).
-Feel free to use and adapt it for your own purposes.
+### Create a new Technology Radar release
+For a new Technology Radar release, create a folder of the release date (YYYY-MM-DD) under `./radar`.
 
-## Usage
+### Maintaining content
+The items are written in Markdown (`.md`) format.
 
-1. include `d3.js` and `radar.js`:
+Each file has a meta header where the attributes of the item are listed:
 
-```html
-<script src="https://d3js.org/d3.v4.min.js"></script>
-<script src="https://flaconi.github.io/tech-radar/release/radar-0.9.js"></script>
+```
+---
+title:      "JavaScript"
+ring:       adopt
+quadrant:   languages-and-frameworks
+tags: [frontend, coding]
+---
+
+Text goes here. You can use **markdown** here.
 ```
 
-2. insert an empty `svg` tag:
+Following front-matter attributes are possible:
 
-```html
-<svg id="radar"></svg>
-```
+- **title**: Name of the Item
+- **quadrant**: Quadrant. One of `languages-and-frameworks` (for `Languages and Frameworks` quadrant),
+  `methods-and-patterns`(for `Techniques` quadrant), `platforms-and-aoe-services`
+  (for `Platforms` quadrant), `tools` (for `Tools` quadrant)
+- **ring**: Ring section in radar. One of `trial`, `assess`, `adopt`, `stop`
+- **tags**: Optional tags for filtering.
+- **featured**: (Optional, default "true") If you set this to "false", the item
+  will not be visible in the radar quadrants but still be available in the overview.
 
-3. configure the radar visualization:
-
-```js
-radar_visualization({
-  repo_url: "https://github.com/flaconi/tech-radar",
-  svg_id: "radar",
-  width: 1450,
-  height: 1000,
-  scale: 1.0,
-  colors: {
-    background: "#fff",
-    grid: "#bbb",
-    inactive: "#ddd"
-  },
-  // Some font families might lead to font size issues
-  // Arial, Helvetica, or Source Sans Pro seem to work well though
-  font_family: "Arial, Helvetica",
-  title: "My Radar",
-  quadrants: [
-    { name: "Bottom Right" },
-    { name: "Bottom Left" },
-    { name: "Top Left" },
-    { name: "Top Right" }
-  ],
-  rings: [
-    { name: "INNER",  color: "#5ba300" },
-    { name: "SECOND", color: "#009eb0" },
-    { name: "THIRD",  color: "#c7ba00" },
-    { name: "OUTER",  color: "#e09b96" }
-  ],
-  print_layout: true,
-  links_in_new_tabs: true,
-  entries: [
-   {
-      label: "Some Entry",
-      quadrant: 3,          // 0,1,2,3 (counting clockwise, starting from bottom right)
-      ring: 2,              // 0,1,2,3 (starting from inside)
-      moved: -1             // -1 = moved out (triangle pointing down)
-                            //  0 = not moved (circle)
-                            //  1 = moved in  (triangle pointing up)
-                            //  2 = new       (star)
-   },
-    // ...
-  ]
-});
-```
+The name of the .md file acts as item identifier and may overwrite items with
+the same name from older releases.
 
-Entries are positioned automatically so that they don't overlap. The "scale" parameter can help
-in adjusting the size of the radar.
+If an item is overwritten in a new release, the attributes from the new item are
+merged with the old ones, and a new history entry is created for that item.
 
-As a working example, you can check out `docs/index.html` &mdash; the source of our [public Tech
-Radar](http://flaconi.github.io/tech-radar/).
+You can integrate images in your markdown. Put the image files in your public folder and reference them:
 
-## Deployment
+```
+![an image](/images/an-image.png)
+```
 
-Tech Radar is a static page, so it can be deployed using any hosting provider of your choice offering static page hosting.
+### Content Guidelines
+You can update the rings and the quadrants in the `config.json` file. If you update the names of the rings and quadrants,
+you will need to update the technologies .md files accordingly.
 
-## Local Development
+The text on the "How to use the Flaconi Technology Radar" page can be updated in the `about.md` file.
 
-1. install dependencies with yarn (or npm):
+## Development
 
-```
-yarn 
-```
+### Host the application under a sub path
+To host the application under a sub path, set the environment variable `PUBLIC_URL`, e.g. "/tech-radar".
+The default is `/`.
 
-2. start local dev server:
+> For local development you can use `/build` and use this for the following steps.
 
+### Build the radar
 ```
-yarn start
+yarn install
+yarn serve
 ```
 
-3. your default browser should automatically open and show the url
- 
+Then open the Tech Radar here: http://localhost:3000/tech-radar
+
+### Build the radar with static files
 ```
-http://localhost:3000/
+yarn install
+yarn build
 ```
 
+## Note
+The Flaconi Technology Radar are built starting from the [AOE Tech Radar content](https://www.aoe.com/techradar/index.html).
+If you want to build your own Technical Radar you may want to have a look at the [AOE Tech Radar GitHub repository](https://github.com/AOEpeople/aoe_technology_radar).
+
 ## License
 
 ```

radar/2024-01-02/adr.md

@@ -7,4 +7,4 @@ tags: []
 An Architecture Decision Record (ADR) is a document that captures an important architectural decision made during a project, 
 along with the context, reasoning, and consequences of the decision. It serves as a reference for why a particular 
 decision was made, helping teams understand the thought process behind architectural choices.
-```
+

radar/2024-01-02/amazon_api_gateway.md

@@ -8,4 +8,4 @@ tags: [infrastructure, aws]
 to create, publish, maintain, monitor, and secure APIs at any scale. It replaces our old Amazon ELB based gateway to improve
 developer experience and improve the security of our APIs. It is used in various places to expose our services to the public internet.
 For new projects only the Amazon Api Gateway should be used to expose services to the public internet. All existing projects should be migrated to the Amazon Api Gateway.
-```
+

radar/2024-01-02/amazon_cloudfront.md

@@ -7,4 +7,4 @@ tags: [infrastructure, aws]
 [Amazon CloudFront](https://aws.amazon.com/cloudfront/) securely delivers content with low latency and high transfer speeds.
 We use it for our [own cdn](https://cdn.flaconi.net) to deliver static files and assets to our users. It is also in front
 of our api gateway to provide caching for some api endpoints and to reduce the load on our backend services.
-```
+

radar/2024-01-02/amazon_dynamodb.md

@@ -7,4 +7,4 @@ tags: [infrastructure, aws]
 [Amazon DynamoDB](https://aws.amazon.com/dynamodb/) is a serverless, NoSQL, fully managed database with single-digit millisecond performance at any scale.
 We use it for projects where we need a NoSQL database and do not want to manage the database ourselves.
 For new projects always a managed database should be used, but the choice between Amazon RDS and Amazon DynamoDB should be made based on the requirements of the project.
-```
+

radar/2024-01-02/amazon_ecs.md

@@ -8,4 +8,4 @@ tags: [infrastructure, aws]
 helps you to more efficiently deploy, manage, and scale containerized applications.
 Currently, we are using it in a small amount of projects. We are still evaluating the service and its benefits for our use cases.
 We see a potential to use it as a replacement for costly lambda functions in some projects.
-```
+

radar/2024-01-02/amazon_elastic_cache_redis.md

@@ -6,4 +6,4 @@ tags: [infrastructure, aws]
 ---
 [Amazon ElastiCache Redis](https://aws.amazon.com/elasticache/redis/) is an in-memory data store that provides microsecond latency to power internet-scale, real-time applications.
 We use that mostly in api facing services to cache data that is expensive to compute or retrieve.
-```
+

radar/2024-01-02/amazon_lambda.md

@@ -7,4 +7,4 @@ tags: [infrastructure, aws]
 [Amazon Lambda](https://aws.amazon.com/lambda/) is a compute service that runs your code in response to events and automatically 
 manages the compute resources, making it the fastest way to turn an idea into a modern, production, serverless applications.
 We use it for nearly all of our services.
-```
+

radar/2024-01-02/amazon_rds_mysql.md

@@ -7,4 +7,4 @@ tags: [infrastructure, aws]
 [Amazon RDS for MySQL](https://aws.amazon.com/rds/mysql) is an easy to manage relational database optimized for total cost of ownership.
 We only use it for some projects where we need a relational database and do not want to manage the database ourselves.
 For new projects always a managed database should be used, but the choice between Amazon RDS and Amazon DynamoDB should be made based on the requirements of the project.
-```
+

radar/2024-01-02/amazon_s3.md

@@ -6,4 +6,4 @@ tags: [infrastructure, aws]
 ---
 [Amazon S3](https://aws.amazon.com/s3/) is an object storage built to retrieve any amount of data from anywhere.
 It is used in various places to store securely data for our various backend services or serve as a storage for static files.
-```
+

radar/2024-01-02/amazon_sns.md

@@ -8,4 +8,4 @@ tags: [infrastructure, aws]
 It was used in the beginning to allow a simple way to send commercetools notifications to our services, but was 
 replaced by Amazon EventBridge. It is still used in some places, but should be replaced by Amazon EventBridge where possible. 
 New Projects should not use Amazon SNS anymore.
-```
+

radar/2024-01-02/amazon_sqs.md

@@ -8,4 +8,4 @@ tags: [infrastructure, aws]
 It is used in various places to decouple services and allow them to communicate asynchronously. 
 It is used a lot in combination with Amazon Lambda, also step functions and EventBridge Pipes are using it.
 When ever you need to decouple services and want the ability to retry errors in processing later, Amazon SQS is a good choice.
-```
+

radar/2024-01-02/amazon_step_functions.md

@@ -10,4 +10,4 @@ Step Functions is a good choice for simple processes like CRUD operations agains
 It is also a good choice for more complex workflows where only a few steps are run inside a lambda function. That 
 overall reduces the maintenance overhead of lambda services as they become much smaller and less complex. Also,
 Step Functions visualizes the workflow in a state machine, which makes it easier to understand and debug.
-```
+

radar/2024-01-02/cloudflare.md

@@ -6,4 +6,4 @@ tags: [infrastructure]
 ---
 [Cloudflare](https://www.cloudflare.com) is used as our dns provider and for caching and security features. 
 It is used in front of our web shops for the various markets. 
-```
+

radar/2024-01-02/continuous_integration.md

@@ -10,4 +10,3 @@ after which automated builds and tests are run.
 
 The webshop has a fully automated end-to-end testing suite which is executed in CI and must pass before any code change can be released to production.
 For our backend services, we use GitHub Actions to run our CI/CD pipelines. Only in cases of success a pull request can be merged to the main branch.
-```

radar/2024-01-02/ct_node_client.md

@@ -7,4 +7,4 @@ tags: [engineering, backend, library]
 [Commercetools Node Client](https://github.com/flaconi/ct-node-client) is a sharded library for commercetools. 
 It is a wrapper around the commercetools node.js SDK. It contains optioned setup for our backend services.
 It should be used in all projects that are written in Node.js.
-```
+

radar/2024-01-02/eslint.md

@@ -6,4 +6,3 @@ tags: []
 ---
 [ESLint](https://eslint.org/) statically analyzes your code to quickly find problems. 
 It is built into most text editors and you can run ESLint as part of your continuous integration pipeline.
-```

radar/2024-01-02/github.md

@@ -7,4 +7,3 @@ tags: []
 [GitHub](https://github.com) is a web-based platform that uses Git for version control and collaboration, allowing developers to store, 
 manage, and share code repositories. It provides tools for issue tracking, project management, and team collaboration, 
 making it easier for individuals and teams to work on software projects together.
-```

radar/2024-01-02/github_actions.md

@@ -5,4 +5,3 @@ ring: adopt
 tags: []
 ---
 [GitHub Actions](https://github.com/features/actions) is used extensively for Continuous Integration (CI) across Flaconi including testing and releasing.
-```

radar/2024-01-02/github_copilot.md

@@ -8,4 +8,3 @@ tags: []
 Integrated into code editors like Intellij, it suggests code snippets, functions, and even whole lines as you type, based on natural 
 language prompts or existing code. Copilot learns from public code repositories, helping developers speed up coding, explore new libraries, 
 and reduce repetitive work.
-```

radar/2024-01-02/iac.md

@@ -7,4 +7,4 @@ tags: []
 Infrastructure as code (IaC) is the ability to provision and support your computing infrastructure using code instead of manual processes and settings. Any application environment requires many infrastructure components like operating systems, database connections, and storage. Developers have to regularly set up, update, and maintain the infrastructure to develop, test, and deploy applications.
 
 Manual infrastructure management is time-consuming and prone to error—especially when you manage applications at scale. Infrastructure as code lets you define your infrastructure's desired state without including all the steps to get to that state. It automates infrastructure management so developers can focus on building and improving applications instead of managing environments. Organizations use infrastructure as code to control costs, reduce risks, and respond with speed to new business opportunities.
-```
+

radar/2024-01-02/java.md

@@ -8,4 +8,4 @@ tags: [engineering, backend]
 To reduce the number of programming languages in use, we recommend to reduce the use of Java. Java is a great language
 , but in engineering we have good knowledge in Node.js. Also, we maintain sharded libraries for
 various use cases, and we need to maintain and implement them also for java.
-```
+

radar/2024-01-02/monitoring_service.md

@@ -7,4 +7,3 @@ tags: [monitoring]
 [Monitoring Service](https://github.com/Flaconi/monitoring-service) creating NewRelic alerts and dashboards for the given definitions per repo. 
 It is invoked through a GitHub workflow and handles at the moment custom alerts static and baseline, it also provides 
 a json schema to be used by the GitHub action to check if the monitoring definitions are valid.
-```

radar/2024-01-02/monoliths.md

@@ -7,4 +7,4 @@ tags: []
 A monolithic architecture is a traditional model of a software program, which is built as a unified unit that is self-contained 
 and independent of other applications. The word “monolith” is often attributed to something large and glacial, 
 which isn’t far from the truth of a monolith architecture for software design.
-```
+

radar/2024-01-02/node_logger.md

@@ -7,4 +7,4 @@ tags: [engineering, backend, library]
 [Node Logger](https://github.com/Flaconi/lib-logger/tree/master/packages/node-logger) is a sharded library and wrapper around 
 [winston](https://github.com/winstonjs/winston). It contains best practices for logging in our backend services and also
 a fingers crossed logger. It should be used in all projects that are written in Node.js.
-```
+

radar/2024-01-02/nodejs.md

@@ -8,4 +8,4 @@ tags: [engineering, backend]
 [Node.js](https://nodejs.org/en) is an open source, no browser JavaScript execution runtime.
 In the engineering department, it is used for various backend services and microservices powered by Express.js in 
 our AWS Lambda Environment.
-```
+

radar/2024-01-02/python.md

@@ -8,4 +8,4 @@ tags: [engineering, backend]
 To reduce the number of programming languages in use, we recommend to reduce the use of Python. Python is a great language
 and perfect for data science, but in engineering we have good knowledge in nodejs. Also, we maintain sharded libraries for
 various use cases, and we need to maintain and implement them also for python.
-```
+

radar/2024-01-02/shared_libraries.md

@@ -6,4 +6,4 @@ tags: []
 ---
 With the creation of so many microservices, it is inevitable that we end up creating similar functionality. 
 Where possible we should look to create shared libraries to enable reuse of common functionality.
-```
+

radar/2024-01-02/template_projects.md

@@ -6,4 +6,4 @@ tags: []
 ---
 It is important that we standardise the approach we take when setting up new services, and where appropriate we supply template projects to facilitate this. 
 Currently, we have only one for Node.js based services: https://github.com/Flaconi/nodejs-api-lambda-boilerplate
-```
+

radar/2024-01-02/terragrunt.md

@@ -5,4 +5,3 @@ ring: adopt
 tags: []
 ---
 [Terragrunt](https://terragrunt.gruntwork.io/) is a flexible orchestration tool that allows Infrastructure as Code to scale.
-```

radar/2024-01-02/typescript.md

@@ -8,4 +8,4 @@ tags: [engineering, backend]
 [TypeScript](https://www.typescriptlang.org/) is a language that gets transpiled to native JavaScript code.
 It is a superset of JavaScript and adds static typing to the language. This makes it easier to catch errors.
 It is currently used in all our Node.js projects and is the preferred language for new projects.
-```
+