Quick Start

We’re excited to have you on board. Your personal optimization environment is now live and ready for action. Akamas Insights is designed to give you a full-stack view of your Kubernetes world analyzing everything from node infrastructure to fine-tuning JVM and Node.js runtimes.

To get you from "setup" to "savings" in just a few minutes, follow this quickstart. This guide will use Dynatrace as your observability tool; if you want to use another provider, skip the first and second section of this tutorial and follow the right path for your chosen provider.

1. Get Your Dynatrace Credentials Ready

Before we plug in the data, we need to make sure the "bridge" to Dynatrace is ready. You will need:

• Your Endpoint URL: This is your Dynatrace environment address, formatted as https://{your-environment-id}.live.dynatrace.com.

• An API Token: Head over to your Dynatrace settings and generate a token with metrics.read, entities.read, and problems.read permissions. These allow Akamas to see the metrics it needs to build your optimization map.

2. Import your Metrics

Now, let’s connect the two platforms. Head over to the Data Sources page in the sidebar.

1. Find the Dynatrace tile and click Connect.

2. Drop in your URL and Token.

3. Hit Test Connection to make sure the handshake is successful, then click Save.

With the connection live, it’s time to bring in the data. Akamas doesn't just look at a snapshot; it analyzes your historical trends to give you reliable advice.

1. Navigate to Integrations > Data Imports and click Start New Import.

2. Pick your window: We recommend starting with the default time range to get a solid baseline.

3. For your first run, the default Time Resolution (5 minutes) is the perfect balance between speed and detail.

The import usually takes anywhere from a few minutes to a couple of hours depending on your cluster's size. You can leave the page, the process continues automatically.

3. Explore the Findings

Once the status turns to Completed, your Home dashboard will transform. This is where the magic happens.

The first thing you should notice is the Tuning Profile selector in the header. These profiles act as the "brain" of the recommendation engine, allowing you to control how aggressively Akamas optimizes your resources based on your risk tolerance.

1. Max Stability: Prioritizes safety and reliability above all else. It maintains larger safety margins and lower utilization targets, making it ideal for mission-critical production workloads where stability is the only priority.

2. Balanced: The default strategy that offers a pragmatic mix of cost savings and risk mitigation. It is suitable for the majority of general-purpose workloads.

3. Max Savings: Minimizes safety margins to push for maximum cost reduction. This is perfect for fault-tolerant, non-production, or highly elastic environments.

Look at the difference between the Balanced profile and the Max Savings profile in your dashboard. By switching to Max Savings, you can see the Estimated Savings jump from $739/mo (a 33% reduction) to $1,016/mo (a 45% reduction). Notice how the suggested CPU Reduction also intensifies from 38% to 56% to achieve these higher savings.

The Findings section provides a high-level health check across three critical categories:

1. Efficiency: Identifies where you are over-provisioned. It shows your potential monthly savings and the percentage of CPU and Memory you can safely reclaim.

2. Reliability: Scores your cluster’s stability. It flags risks like CPU throttling (which degrades performance) or OOMKill threats (where containers crash due to low memory limits).

3. Best Practices: Ensures your configurations align with Kubernetes standards, such as having proper resource requests and limits in place.

To help you start where it matters most, Akamas Insight highlights Top Recommendations prioritized by impact:

1. Highest Savings: The single workload that will return the most money to your budget (e.g., the efs-csi-controller saving $32/mo).

2. Highest Reliability Risk: The workload most in danger of failure (e.g., logstash with 9 critical risks)

3. Highest Priority: A weighted score that combines savings and risk to tell you exactly where your attention is needed most.

4. Analyze the Recommendations

Akamas Insights provides intelligent, AI-driven recommendations across two main layers: Node Groups and Workloads. These recommendations are designed to ensure your clusters operate at peak efficiency without sacrificing performance.

4.1 Node Groups Recommendations

This feature helps you identify opportunities to switch to more cost-effective instance types while maintaining the capacity your workloads require.

To begin, navigate to the Clusters page. At the top of the interface, you will find essential tools for narrowing your focus:

1. Cluster Selector: Use the dropdown to choose the specific environment you wish to analyze.

2. Tuning Profile: Select a profile to adjust how the AI calculates its recommendations.

Once a cluster is selected, the Node groups tab provides a high-level Optimization Summary:

• Total Savings: Displays the immediate monthly impact of applying Akamas recommendations (e.g., a $638/mo or 29% reduction).

• Cost Comparison Chart: A visual bar chart comparing your Current Cost against the projected cost With Akamas, allowing for a quick sanity check of the potential ROI.

The recommendation table breaks down exactly which nodegroups should be modified:

• Current vs. Recommended: The platform compares your current instance type (e.g., i4i.xlarge) against a recommended alternative (e.g., r6a.xlarge).

• Cost & Savings: It details the specific savings for that group (e.g., $638.00/mo).

• Priority Level: Recommendations are tagged by priority (e.g., High) to help you focus on the most impactful changes first.

Clicking into a specific nodegroup provides a comprehensive Comparison table and Performance Analysis charts:

Akamas analyzes all possible instance types, identifying the Cheapest option versus your Current selection. The table lists technical specs like CPU Cores, Memory (GiB), and price per hour.

The Performance Analysis charts provide 7-day historical views (based on your metrics import) for:

• Node Count Over Time: Comparing current node usage vs. the recommended instance capacity.

• CPU, Memory, and Pods Capacity: These charts show Current Allocatable vs. Current Used metrics, overlaid with the capacity provided by the recommended instance (e.g., r6a.xlarge), ensuring the new type can safely handle your peak loads.

4.2 Workload Recommendations

While Node Group optimization handles your underlying infrastructure, Workload Recommendations focus on the applications themselves. Akamas Insights uses a full-stack approach, analyzing both the Kubernetes pod configuration and the internal application runtime (like the JVM) to identify optimization opportunities at every level.

Moving on the App Runtimes tab, the Findings dashboard provides a comprehensive summary of issues across your entire environment.

You can quickly see the total number of issues for Efficiency, Reliability, and Best Practices.

The interface breaks down specific common problems, such as:

• Efficiency: "JVM heap space usage very low" or "Node.js heap much smaller than memory limit".

• Reliability: "Memory limits too small for the JVM" or "JVM GC time young too high".

• Best Practices: "JVM without GC configuration" or "Node.js without semi-space configuration".

When you select a specific workload, Akamas Insights provides a unified view of recommended changes for both the Kubernetes container and the application runtime.

• Container Right-sizing: The platform compares your Current values vs your Actual usage for CPU and Memory Requests and Limits. For example, a workload might be safely reduced from 1000 millicores to 200 millicores, resulting in a significant cost reduction.

• Runtime Tuning (JVM / NodeJS): Akamas looks inside the container to optimize the application runtime. It identifies the optimal Heap Size, suggesting reductions if the current allocation is wasteful (e.g., reducing from 494 MiB to 347 MiB).

• Expected Impact: Every recommendation includes a summary of its impact, showing estimated monthly Savings, the percentage of cost reduction, and the specific number of Efficiency, Reliability, and Best Practice issues solved by applying the change.

To build trust in these recommendations, Akamas provides a granular look at the workload's actual resource consumption.

• CPU Usage: Compare Average Used, Peak Used, and Throttling millicores against your configured Requests and Limits.

• Memory Usage: Analyze total memory usage (Avg and Peak) alongside a specialized breakdown of Heap Used vs. Off Heap Used. These visualizations clearly show the "buffer" between actual usage and current limits, justifying the proposed downsizing.

Each workload page lists the specific "why" behind the recommendations:

• Efficiency: Flags like "CPU utilization much lower than requests" or "Guaranteed QoS inefficient for bursty workload" explain exactly where resources are being wasted.

• Runtime Health: Detailed flags such as "JVM heap space usage very low" or "JVM without GC configuration" highlight internal application inefficiencies that standard Kubernetes monitors might miss.

5. Apply the Recommendations

Once you have analyzed the impact and confirmed that the suggested changes align with your goals, Akamas Insights allows you to move from analysis to action with just a few clicks. In the Workload Details page, you will find the Apply Now button, which launches a guided procedure to implement the new configuration.

Akamas provides three distinct paths to suit your workflow, whether you are performing quick tests or following strict corporate deployment processes:

1. kubectl Command: The fastest method for applying changes directly to running resources. The system generates a kubectl patch command that you can run in your terminal for immediate updates to individual workloads.

2. YAML File: Best for reviewing changes and manual GitOps workflows. You can download the recommended configuration as a YAML snippet and merge it into your deployment files, ensuring changes are persisted in your source control.

3. GitOps Integration (Recommended): The most advanced and secure method. Akamas can automatically create a merge request with the recommended changes directly in your Git repository (GitLab or GitHub) for team review.

The GitOps Integration turns Akamas into an active collaborator for your DevOps team, ensuring that infrastructure changes go through code review before reaching production.

When you select Open a merge request, Akamas launches a wizard that automates the deployment updates:

• Repository Selection: Choose the GitLab/GitHub project containing your Kubernetes deployment manifests.

• Automated Branching: Akamas creates a new branch (e.g., feat/resource-optimization-...) starting from your source branch (e.g., main or develop).

• File Path: Specify the path to the manifest file (e.g., values.yaml) and the exact location of the resources block using dot notation (e.g., spec.containers.resources).

• Full-Stack Support (JAVA_OPTS): If the recommendation includes JVM optimization, an additional field allows you to specify the path to the JAVA_OPTS environment variable to update heap parameters directly in the code.

In the final step of the wizard, you can view a summary of the changes to be applied, including the resource configuration preview and the target file. Once you click Create Merge Request, Akamas commits the changes and opens the request in GitLab or GitHub, allowing you to review and merge the updates according to your standard internal procedures.

6. Conclusion

Congratulations! You have successfully navigated the first steps of your journey with Akamas Insights. You now have unprecedented visibility into how your Kubernetes clusters utilize resources from the underlying node infrastructure down to the heart of your Java and Node.js applications.

Remember that optimization is not a one-time event, but a continuous process. As your applications evolve and your workloads change, Akamas will continue to analyze your historical data to provide up-to-date, intelligent recommendations.

What’s Next?

• Monitor Results: After applying your first set of recommendations, observe how the Efficiency and Reliability scores evolve on your Home dashboard.

• Engage Your Team: Use the generated savings reports to demonstrate tangible value to your stakeholders and streamline collaboration.

• Refine Your Costs: Configure custom pricing rules in the Settings to reflect your specific cloud provider discounts and ensure your savings estimates are pinpoint accurate.

We are here to help you get the most out of your environments. If you have any questions or wish to explore advanced features like custom optimization profiles, do not hesitate to reach out to our support team.

Happy Optimizing!