You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by GitBox <gi...@apache.org> on 2022/06/25 07:13:38 UTC
[GitHub] [camel-website] SubhasmitaSw opened a new pull request, #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
SubhasmitaSw opened a new pull request, #865:
URL: https://github.com/apache/camel-website/pull/865
Featuring issues from the camel-k repo:
#[3340](https://github.com/apache/camel-k/issues/3340#event-6761087660)
#[3339](https://github.com/apache/camel-k/issues/3339#event-6760942255)
cc @astefanutti
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] SubhasmitaSw commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
SubhasmitaSw commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r906700149
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the client (Kamel)
+
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
+
+```
+kamel install --operator-resources requests.cpu=256m --operator-resources limits.cpu=500m --operator-resources limits.memory=512Mi ...
+```
+The operator Pod's Maven builds are most likely the largest contributor to compute resource consumption (assuming you use the default build strategy). As a result, the resource needs must be determined properly. The conditions listed below are reasonable defaults that should work in most cases, probably giving you the freedom to customize it as per your system to leverage the full potential of it.
+
+```
Review Comment:
specify the yaml language usage for the last example you mean? I'm not very clear here
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] astefanutti commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
astefanutti commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r906678674
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the client (Kamel)
+
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
+
+```
+kamel install --operator-resources requests.cpu=256m --operator-resources limits.cpu=500m --operator-resources limits.memory=512Mi ...
+```
+The operator Pod's Maven builds are most likely the largest contributor to compute resource consumption (assuming you use the default build strategy). As a result, the resource needs must be determined properly. The conditions listed below are reasonable defaults that should work in most cases, probably giving you the freedom to customize it as per your system to leverage the full potential of it.
+
+```
Review Comment:
Add `yaml` language.
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the client (Kamel)
Review Comment:
"installing the operator"
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the client (Kamel)
+
Review Comment:
Remove the extra empty line.
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
Review Comment:
I should probably be added to the `content/blog/2022/06/` directory.
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the client (Kamel)
+
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
+
+```
+kamel install --operator-resources requests.cpu=256m --operator-resources limits.cpu=500m --operator-resources limits.memory=512Mi ...
+```
+The operator Pod's Maven builds are most likely the largest contributor to compute resource consumption (assuming you use the default build strategy). As a result, the resource needs must be determined properly. The conditions listed below are reasonable defaults that should work in most cases, probably giving you the freedom to customize it as per your system to leverage the full potential of it.
+
+```
+resources:
+ limits:
+ cpu: "4"
+ memory: 3Gi
+ requests:
+ cpu: 500m
+ memory: 512Mi
+```
+---
+Feedback or questions can be sent to the [camel-k](https://github.com/SubhasmitaSw/camel-k) community by raising issues/discussing your concerns in the [mailing list](https://camel.apache.org/community/mailing-list/) or [IRC](https://camel.zulipchat.com/#) channels.
Review Comment:
`https://github.com/SubhasmitaSw/camel-k` -> `https://github.com/apache/camel-k`
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
Review Comment:
I'd suggest "Scaling the Camel K operator vertically to improve the integration build time".
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
Review Comment:
`["SubhasmitaSw","astefanutti"]`
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] SubhasmitaSw commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
SubhasmitaSw commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r907669109
##########
content/blog/2022/06/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,100 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: false
+authors: ["SubhasmitaSw", "astefanutti"]
+categories: ["Camel-K"]
+preview: "Scaling the Camel K operator vertically to improve the integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the operator (Kamel)
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
Review Comment:
apologies, didn't know about the in-repo links. I've updated.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] github-actions[bot] commented on pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
github-actions[bot] commented on PR #865:
URL: https://github.com/apache/camel-website/pull/865#issuecomment-1168487637
🚀 Preview is available at https://pr-865--camel.netlify.app
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] astefanutti commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
astefanutti commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r906700757
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the client (Kamel)
+
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
+
+```
+kamel install --operator-resources requests.cpu=256m --operator-resources limits.cpu=500m --operator-resources limits.memory=512Mi ...
+```
+The operator Pod's Maven builds are most likely the largest contributor to compute resource consumption (assuming you use the default build strategy). As a result, the resource needs must be determined properly. The conditions listed below are reasonable defaults that should work in most cases, probably giving you the freedom to customize it as per your system to leverage the full potential of it.
+
+```
Review Comment:
Yes, like `` ```yaml ``.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] github-actions[bot] commented on pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
github-actions[bot] commented on PR #865:
URL: https://github.com/apache/camel-website/pull/865#issuecomment-1166336403
🚀 Preview is available at https://pr-865--camel.netlify.app
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] davsclaus commented on pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
davsclaus commented on PR #865:
URL: https://github.com/apache/camel-website/pull/865#issuecomment-1168306545
There is a preview now and it looks good.
The date of the blog post should be updated to today, then we can merge it.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] github-actions[bot] commented on pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
github-actions[bot] commented on PR #865:
URL: https://github.com/apache/camel-website/pull/865#issuecomment-1168304828
🚀 Preview is available at https://pr-865--camel.netlify.app
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] SubhasmitaSw commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
SubhasmitaSw commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r906701079
##########
content/blog/2022/03/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,105 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
+authors: [SubhasmitaSw][astefanutti]
+categories: ["Camel-K"]
+preview: "Using performance benchmarks to demonstrate the optimised camel-k integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the client (Kamel)
+
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
+
+```
+kamel install --operator-resources requests.cpu=256m --operator-resources limits.cpu=500m --operator-resources limits.memory=512Mi ...
+```
+The operator Pod's Maven builds are most likely the largest contributor to compute resource consumption (assuming you use the default build strategy). As a result, the resource needs must be determined properly. The conditions listed below are reasonable defaults that should work in most cases, probably giving you the freedom to customize it as per your system to leverage the full potential of it.
+
+```
Review Comment:
done!
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] astefanutti commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
astefanutti commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r906717154
##########
content/blog/2022/06/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,100 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
Review Comment:
This has to be removed for the post to be published :)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] astefanutti merged pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
astefanutti merged PR #865:
URL: https://github.com/apache/camel-website/pull/865
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] astefanutti commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
astefanutti commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r908107145
##########
content/blog/2022/06/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,100 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: false
+authors: ["SubhasmitaSw", "astefanutti"]
+categories: ["Camel-K"]
+preview: "Scaling the Camel K operator vertically to improve the integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
Review Comment:
It seems it's needed to explicitly specify the language for command blocks, i.e., `` ```shell` ``, otherwise the inferred one is different.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] SubhasmitaSw commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
SubhasmitaSw commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r906758553
##########
content/blog/2022/06/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,100 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: true
Review Comment:
sorry, slipped out.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] astefanutti commented on a diff in pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
astefanutti commented on code in PR #865:
URL: https://github.com/apache/camel-website/pull/865#discussion_r907140515
##########
content/blog/2022/06/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,100 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: false
+authors: ["SubhasmitaSw", "astefanutti"]
+categories: ["Camel-K"]
+preview: "Scaling the Camel K operator vertically to improve the integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the operator (Kamel)
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
+
+```
+kamel install --operator-resources requests.cpu=256m --operator-resources limits.cpu=500m --operator-resources limits.memory=512Mi ...
+```
+The operator Pod's Maven builds are most likely the largest contributor to compute resource consumption (assuming you use the default build strategy). As a result, the resource needs must be determined properly. The conditions listed below are reasonable defaults that should work in most cases, probably giving you the freedom to customize it as per your system to leverage the full potential of it.
+
+```yaml
+resources:
+ limits:
+ cpu: "4"
+ memory: 3Gi
+ requests:
+ cpu: 500m
+ memory: 512Mi
+```
+---
+Feedback or questions can be sent to the [camel-k](https://github.com/apache/camel-k) community by raising issues/discussing your concerns in the [mailing list](https://camel.apache.org/community/mailing-list/) or [IRC](https://camel.zulipchat.com/#) channels.
Review Comment:
It should be `[mailing list](/community/mailing-list/)`
##########
content/blog/2022/06/Optimizing-Camel-K-Integration-Build-Time/index.md:
##########
@@ -0,0 +1,100 @@
+---
+title: "Optimizing Camel-K Integration Build Time"
+date: 2022-06-24
+draft: false
+authors: ["SubhasmitaSw", "astefanutti"]
+categories: ["Camel-K"]
+preview: "Scaling the Camel K operator vertically to improve the integration build time."
+---
+
+The Integration is the resource which represents the actual Camel application and building a container image that packages the integration within an elevated cloud platform (be it locally in a Minikube or K8s hosted cluster to Openshift clusters) takes ample amount of time.
+
+### Enhancing the Camel-K Integration build time
+
+Our goal was to reduce overhead and improve user experience. We were able to narrow down the major contributors that had a significant influence on the integration build time.
+
+We identified that the CPU resources available to the operator can have a significant impact on integration build time. Following that, we modified the Camel-K operator to be aware of the CPU quota set on the operator container, and then we made the Maven process and container image layers push scaling vertically based on the CPU quota. Users may use Maven to download dependencies in parallel by configuring a group of concurrent threads. We modified the technique for configuring the build by default to account for the maximum number of CPU cores available simultaneously. In addition we modified the container Image push method to use the parallelization.
+
+The effect of faster build times may be seen in the benchmark comparisons below.
+
+### System Configuration
+
+
+| Device | Chip | Total Number of Cores | Memory |
+| ------- | ----- | -------- |--------|
+|MacBook Air (M1)| Apple Sillicon M1 | 8 core CPU (4 performance and 4 efficiency), 7 Core GPU | 8GB
+
+### Environment Configuration
+
+The tests are graded using the following configurations:
+
+1. **Minikube Version:** v1.25.2
+2. **Minimum no. of cores:** 2
+3. **Maximum no. of cores:** 4
+4. **Maximum memory used:** 3933 MB
+5. **Registry Addon:** Enabled
+
+*PS: These metrics are exclusive to my system; they may differ for others.*
+
+### Evaluating Performing
+
+1. Start a new minikube cluster with minimum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 2 --memory=3GB
+ ```
+2. Setup the Camel-K environment by installing the operator (Kamel)
+ ```
+ kamel install
+ ```
+3. Run a sample Integration in the dev mode
+ ```
+ kamel run --env MY_ENV_VAR="hello world" Env.java --dev
+ ```
+4. Get the build duration
+ The build duration is ~6mins using default usage of cores available.
+
+ 
+
+5. Delete the minikube cluster to reinstate the environment and avoid any usage of previously build Integration images.
+ ```
+ minikube delete
+ ```
+6. Start a new minikube cluster with maximum permissible cores and maximum memory (as per docker desktop)
+ ```
+ minikube start --addons registry --cpus 4 --memory=3GB
+ ```
+7. Repeat steps 2 and 3.
+8. Get the build duration
+ The build duration is ~2mins utilizing the maximum CPU cores available for my system.
+
+ 
+
+#### Benchmark Comparison
+
+| Integration | Integration Kit Name | Build Time |CPUs |
+| -------- | -------- | -------- |----- |
+| Env.java | kit-caopeg968cvc73fie4t0 | 6m26.044974722s | 2 |
+|Env.java | kit-caort9bmr3lc73emiifo | 2m24.9183443385s | 4
+
+It is clear that the build time has decreased significantly; with more powerful systems (e.g., 16, 32 cores), the build time will be reduced to a few tens of seconds.
+
+### Leveraging the benefit
+
+To utilise this newly available functionality and apply CPU constraints on operator deployment, select from the following example measures or consult the [Resource Management](https://camel.apache.org/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources) guide to modify it about their own needs.
Review Comment:
The link should be `/camel-k/1.9.x/installation/advanced/resources.html#scheduling-infra-pod-resources`.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
[GitHub] [camel-website] astefanutti commented on pull request #865: Blog to demonstrate the optimised camel-k integration build time using performance benchmarks
Posted by GitBox <gi...@apache.org>.
astefanutti commented on PR #865:
URL: https://github.com/apache/camel-website/pull/865#issuecomment-1168495985
Thanks!
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: commits-unsubscribe@camel.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org