Infrastructure Management

3 weeks back while I was working on a Kubernetes project, saw a very common bad practice, i.e. image size is 8 GB which could have been just 436 MB (Multi-stage Build)!!!! After working on such numerous projects, here I have made a list of best practices for containers: Use Minimal Base Images: Start with minimal base images like Alpine Linux or Distroless to reduce the attack surface and improve container startup times. Single Concern per Container: Each container should have only one responsibility. If an application has multiple components (e.g., web server, database etc), they should be split into separate containers and managed as separate services. Stateless Applications: Design your applications to be stateless as much as possible. This allows Kubernetes to easily scale, restart, or replace containers without losing data. Liveness and Readiness Probes: Use liveness probes to let Kubernetes know when to restart a container and readiness probes to know when a container is ready to start accepting traffic. Resource Limits: Set resource requests and limits for CPU and memory to ensure that the container gets its required resources and doesn't consume more than it should. Security: Run containers with a non-root user. Use network policies to control communication between pods. Regularly scan container images for vulnerabilities. Use Kubernetes RBAC (Role-Based Access Control) to limit permissions. Immutable Containers: Avoid making changes to running containers. Instead, create a new container image and deploy it. This ensures consistency across environments. Use Labels and Annotations: Use labels for organizing and selecting groups of resources. Annotations can be used to store additional metadata. Configurations and Secrets: Use ConfigMaps for non-sensitive configuration data and Secrets for sensitive data. Avoid hardcoding configurations in the container image. Logging and Monitoring: Ensure that your applications log to the standard output and standard error streams. This allows Kubernetes to handle and redirect the logs appropriately. Integrate with monitoring tools like Prometheus to keep an eye on the health and performance of your containers. Regularly Update and Patch: Regularly update your container images to include security patches and updates. Use image scanning tools to identify and fix vulnerabilities. Graceful Shutdown: Ensure that your applications handle the SIGTERM signal and shut down gracefully. This allows them to finish processing current requests and release resources before shutting down. Avoid Using latest Tag: Be explicit with container image tags. Avoid using the latest tag as it can lead to unpredictable deployments. Storage Considerations: If your application needs persistent storage, use Persistent Volumes (PV) and Persistent Volume Claims (PVC) in Kubernetes. Ensure that the storage solution you choose is compatible with the dynamic nature of containerized deployments. Follow Sandip Das for more!

For years the data center industry chased bigger. Bigger campuses. Bigger power contracts. 1,000-MW mega facilities. But the AI era is exposing a flaw in that model. AI inference doesn’t want to live 1,000 miles away. When decisions must happen in milliseconds — for power grids, public safety, robotics, financial systems, or smart cities — sending data to a distant hyperscale cloud and waiting for it to come back simply doesn’t work. So the architecture is changing. Instead of one massive campus: • 1,000 smaller urban sites • Compute next to where data is created • AI inference at the edge • Capacity that can scale in weeks, not years That’s the idea behind distributed AI infrastructure. Projects like Project Qestrel are rolling out fleets of edge data centers across U.S. cities — bringing HPC and AI inference directly into metro networks. Hyperscale isn’t going away. But the future of AI won’t be one giant brain in the desert. It will be a nervous system of distributed intelligence. And the closer compute gets to the edge, the faster the world gets. #EdgeComputing #AIInfrastructure #DataCenters #AIInference

If you’re building anything with LLMs, your system architecture matters more than your prompts. Most people stop at “call the model, get the output.” But LLM-native systems need workflows, blueprints that define how multiple LLM calls interact, how routing, evaluation, memory, tools, or chaining come into play. Here’s a breakdown of 6 core LLM workflows I see in production: 🧠 LLM Augmentation Classic RAG + tools setup. The model augments its own capabilities using: → Retrieval (e.g., from vector DBs) → Tool use (e.g., calculators, APIs) → Memory (short-term or long-term context) 🔗 Prompt Chaining Workflow Sequential reasoning across steps. Each output is validated (pass/fail) → passed to the next model. Great for multi-stage tasks like reasoning, summarizing, translating, and evaluating. 🛣 LLM Routing Workflow Input routed to different models (or prompts) based on the type of task. Example: classification → Q&A → summarization all handled by different call paths. 📊 LLM Parallelization Workflow (Aggregator) Run multiple models/tasks in parallel → aggregate the outputs. Useful for ensembling or sourcing multiple perspectives. 🎼 LLM Parallelization Workflow (Synthesizer) A more orchestrated version with a control layer. Think: multi-agent systems with a conductor + synthesizer to harmonize responses. 🧪 Evaluator–Optimizer Workflow The most underrated architecture. One LLM generates. Another evaluates (pass/fail + feedback). This loop continues until quality thresholds are met. If you’re an AI engineer, don’t just build for single-shot inference. Design workflows that scale, self-correct, and adapt. 📌 Save this visual for your next project architecture review. 〰️〰️〰️ Follow me (Aishwarya Srinivasan) for more AI insight and subscribe to my Substack to find more in-depth blogs and weekly updates in AI: https://lnkd.in/dpBNr6Jg

I started by asking AI to do everything. Six months later, 65% of my agent’s workflow nodes run as non-AI code. The first version was fully agentic : every task went to an LLM. LLMs would confidently progress through tasks, though not always accurately. So I added tools to constrain what the LLM could call. Limited its ability to deviate. I added a Discovery tool to help the AI find those tools. Better, but not enough. Then I found Stripe’s minion architecture. Their insight : deterministic code handles the predictable ; LLMs tackle the ambiguous. I implemented blueprints, workflow charts written in code. Each blueprint specifies nodes, transitions between them, trigger conditions for matching tasks, & explicit error handling. This differs from skills or prompts. A skill tells the LLM what to do. A blueprint tells the system when to involve the LLM at all. Each blueprint is a directed graph of nodes. Nodes come in two types : deterministic (code) & agentic (LLM). Transitions between nodes can branch based on conditions. Deal pipeline updates, chat messages, & email routing account for 29% of workflows, all without a single LLM call. Company research, newsletter processing, & person research need the LLM for extraction & synthesis only. Another 36%. The workflow runs 67-91% as code. The LLM sees only what it needs : a chunk of text to summarize, a list to categorize, processed in one to three turns with constrained tools. Blog posts, document analysis, bug fixes are genuinely hybrid. 21% of workflows. Multiple LLM calls iterate toward quality. Only 14% remain fully agentic. Data transforms & error investigations. These tend to be coding tasks rather than evaluating a decision point in a workflow. The LLM needs freedom to explore. AI started doing everything. Now it handles routing, exceptions, research, planning, & coding. The rest runs without it. Is AI doing less? Yes. Is the system doing more? Also yes. The blueprints, the tools, the skills might be temporary scaffolding. With each new model release, capabilities expand. Tasks that required deterministic code six months ago might not tomorrow.

In AWS, Infrastructure as Code (IaC) plays a crucial role, with CloudFormation acting as its core service. Although IaC solutions like Serverless Framework, AWS SAM, and Terraform are eventually converted into CloudFormation templates, the AWS Cloud Development Kit (CDK) stands out by allowing the use of well-known programming languages, including Python, JavaScript, TypeScript, Java, C#, and Go. This method speeds up the learning curve, enabling developers to concentrate more on creating business functionalities rather than getting bogged down by the nuances of infrastructure management. For backend developers, the task of building RESTful APIs has been greatly simplified thanks to serverless technology, which eliminates the complexity of configurations and deployments. This article was authored by one of our team members, Iggy Yuson.

🚀 Revolutionizing Infrastructure Application Management: A GitOps Journey with Terraform, ArgoCD, Kargo🚀 In the ever-evolving world of cloud-native development, a game-changing approach to infrastructure and application deployment that's transformed our team's efficiency and reliability. By combining Terraform's powerful Infrastructure as Code (IaC) capabilities with GitOps principles using ArgoCD, we can create a seamless, version-controlled deployment ecosystem that brings unprecedented clarity and control to our infrastructure management. The Power of Terraform IaC : Terraform has been a game-changer in how we define and provision infrastructure. Instead of manual configurations and error-prone click-ops, we now: 1. Describe our entire infrastructure as code 2. Ensure consistent, repeatable deployments 3. Manage complex multi-cloud environments with ease 4. Leverage state management for precise infrastructure tracking GitOps: A Single Source of Truth : Integrating ArgoCD has taken our deployment strategy to the next level. Now, our entire infrastructure and application state is declaratively defined and automatically synchronized from Git repositories. This means: 1. Every infrastructure change is a pull request 2. Complete audit trail of all modifications 3. Self-healing infrastructure that automatically converges to the desired state 4. Simplified rollbacks and version control Real-World Impact What started as an experiment has become the standard approach. We can dramatically reduced deployment errors, increased team collaboration, and gained unprecedented visibility into our infrastructure lifecycle. 💡 Pro Tip: Start small. Begin by converting one service or environment to this approach and watch the benefits compound. 💡💡💡💡💡 #DevOps #CloudNative #Terraform #GitOps #Kubernetes #ArgoCD #CloudEngineering

The Humanoid Robot Race Has Started — But the Real Innovation Is the AI Infrastructure Behind BMW’s deployment of Figure 03, developed by Figure AI, at its Spartanburg plant is an important milestone in the evolution of industrial automation. Figure is building general-purpose humanoid robots designed to operate in environments created for humans. Unlike traditional industrial robots that are typically fixed in place and programmed for specific tasks, humanoid robots are designed to navigate existing workplaces, use human tools, and adapt to changing conditions through AI. And Figure is not alone. The humanoid robotics market is becoming increasingly competitive, with companies such as Tesla with Optimus, Agility Robotics with Digit, and other emerging players investing heavily in bringing general-purpose robots into real-world environments. BMW spent nearly a year testing Figure 02, where the robot supported body shop operations and contributed to the production of more than 30,000 BMW X3 vehicles. That was a controlled environment: fixed parts, predictable positions, and repeatable movements. With Figure 03, BMW is moving into a more complex challenge: logistics sequencing in Hall 52, supporting the flow of parts for vehicle assembly, including the BMW X3 and upcoming electrified models. This is a much harder problem. In logistics, parts may arrive in different positions or orientations. The robot must understand its surroundings, identify objects, decide how to handle them, and adapt its movements in real time. That is the difference between traditional automation and Physical AI. But the real breakthrough is not just the robot. A humanoid robot only creates value when connected to a broader digital ecosystem: • Digital twins that simulate factories and optimize workflows before deployment. • Integrated IT/OT infrastructure connecting robots, production systems, and operations. • Low-latency networks and edge computing to process vision, touch, and movement data in real time. • AI-powered quality systems that continuously monitor operations and provide rapid feedback. The impact on people may be just as important as the technology. As robots take on repetitive and physically demanding tasks, employees can increasingly focus on higher-value work: supervising intelligent systems, solving exceptions, improving processes, and making decisions where human judgment matters most. The lesson for organizations is clear: Physical AI will not scale through hardware alone. It requires the right digital foundation — and a workforce prepared for a new way of working. The robot is the visible innovation. The real transformation is the combination of AI, infrastructure, and human capability. https://lnkd.in/eDUPt8_r

𝐈 𝐡𝐚𝐯𝐞 𝐬𝐩𝐞𝐧𝐭 𝐭𝐡𝐞 𝐥𝐚𝐬𝐭 𝐲𝐞𝐚𝐫 𝐡𝐞𝐥𝐩𝐢𝐧𝐠 𝐄𝐧𝐭𝐞𝐫𝐩𝐫𝐢𝐬𝐞𝐬 𝐦𝐨𝐯𝐞 𝐟𝐫𝐨𝐦 "𝐈𝐌𝐏𝐑𝐄𝐒𝐒𝐈𝐕𝐄 𝐃𝐄𝐌𝐎𝐒" 𝐭𝐨 "𝐑𝐄𝐋𝐈𝐀𝐁𝐋𝐄 𝐀𝐈 𝐀𝐆𝐄𝐍𝐓𝐒".  The pattern is always the same:  Teams nail the LLM integration and think the hard part is done, then realize they have built 20% of what production actually requires. 𝐇𝐞𝐫𝐞 𝐢𝐬 𝐰𝐡𝐲 𝐞𝐚𝐜𝐡 𝐛𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐛𝐥𝐨𝐜𝐤 𝐦𝐚𝐭𝐭𝐞𝐫𝐬: Reasoning Engine (LLM): Just the Beginning • Interprets intent and generates responses • Without surrounding infrastructure, it is just expensive autocomplete • Real engineering starts when you ask: "How does this agent make decisions it can defend?" Context Assembly: Your Competitive Moat • Where RAG, memory stores, and knowledge retrieval converge • Identical LLMs produce vastly different results based purely on context quality • Prompt engineering does not matter if you are feeding the model irrelevant information Planning Layer: What to Do Next • Breaks goals into steps and decides actions before acting • Separates thinking from doing • Poor planning = agents that thrash or make circular progress Guardrails & Policy Engine: Non-Negotiable • Defines what APIs the agent can call, what data it can access • Determines which decisions require human approval • One misconfigured tool call can cascade into serious business impact Memory Store: Enables Continuity • Short-term state + long-term memory across interactions • Without it, every conversation starts from zero • Context window isn't memory it's just scratchpad Validation & Feedback Loop: How Agents Improve • Logging isn't learning • Capture user corrections, edge cases, quality signals • Best teams treat every interaction as potential training data Observability: Makes the Invisible Visible • When your agent fails, can you trace exactly why? • Which context was retrieved? What reasoning path? What was the token cost? • If you can not answer in under 60 seconds, debugging will kill velocity Cost & Performance Controls: POC vs Product • Intelligent model routing, caching, token optimization are not premature they are survival • Monthly bills can drop 70% with zero accuracy loss through smarter routing What most teams miss: They build top-down (UI → LLM → tools)  when they should build bottom-up (infrastructure → observability → guardrails → reasoning). These 11 building blocks are not theoretical. They are what every production agent eventually requires either through intentional design or painful iteration. 𝐖𝐡𝐢𝐜𝐡 𝐛𝐥𝐨𝐜𝐤 𝐚𝐫𝐞 𝐲𝐨𝐮 𝐜𝐮𝐫𝐫𝐞𝐧𝐭𝐥𝐲 𝐮𝐧𝐝𝐞𝐫𝐢𝐧𝐯𝐞𝐬𝐭𝐢𝐧𝐠 𝐢𝐧? ♻️ Repost this to help your network get started ➕ Follow Anurag(Anu) Karuparti for more PS: If you found this valuable, join my weekly newsletter where I document the real-world journey of AI transformation. ✉️ Free subscription: https://lnkd.in/exc4upeq #GenAI #AIAgents

Kubernetes deployment strategies are NOT one-size-fits-all. A few years ago, we rolled out a new feature using a rolling update across our microservices. It was textbook clean. Zero errors, no downtime. But guess what? ☠️ User complaints poured in within minutes. ☠️ The new logic had a bug that only appeared when v1 and v2 pods coexisted. That day I realized…  a deployment “strategy” isn’t just about uptime. It’s about context. Let’s break it down: 1. 𝐑𝐨𝐥𝐥𝐢𝐧𝐠 𝐃𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭𝐬 Default. Easy. But dangerous if your app state or DB migrations aren’t backward compatible. ☑️ Great for: → Stateless services → Simple patch updates   ❌ Avoid when: → There’s shared state between versions → Feature flags are not in place 2. 𝐁𝐥𝐮𝐞-𝐆𝐫𝐞𝐞𝐧 𝐃𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭𝐬 Zero-downtime. Fast rollback. But infra-heavy. You're duplicating environments. ☑️ Great for: → High-traffic APIs → Major version upgrades → Apps with complex dependencies ❌ Avoid when: → You can’t afford double the infra → Your team isn’t ready to manage parallel prod 3. 𝐂𝐚𝐧𝐚𝐫𝐲 𝐃𝐞𝐩𝐥𝐨𝐲𝐦𝐞𝐧𝐭𝐬 Sexy in theory. Tricky in practice. You need metrics, observability, and automated rollback wired in. ☑️ Great for:  → Risky features → Performance testing in production → Teams with solid SRE/observability culture  ❌ Avoid when: → You’re flying blind (no dashboards, no alerts) → You don’t have progressive rollout automation (like Flagger or Argo Rollouts) Here’s what I’ve learnt. There’s no “best” deployment strategy. There’s only the one that matches your tech stack, team maturity, and business risk appetite. ♻️ 𝐑𝐄𝐏𝐎𝐒𝐓 So Others Can Learn.

Closing the sim-to-real gap in humanoid robotics requires massive simulation throughput and high-fidelity physics validation. WPP recently detailed their engineering pipeline, showing how they reduced reinforcement learning cycle times for complex humanoid locomotion from 24 hours down to less than 60 minutes. The hardware architecture relies on Google Cloud’s new G4 VMs (powered by NVIDIA RTX PRO 6000 Blackwell GPUs) running NVIDIA Isaac Sim, integrated closely with DeepMind’s MuJoCo physics engine. The mechanics: The team mapped raw human mocap data (over 200 degrees of freedom) down to a constrained 29-DOF OpenUSD digital twin. By leveraging a P2P GPU topology to bypass central processing bottlenecks, the infrastructure executed over 3 billion simulations in under an hour. The virtual environment continuously introduced physical micro-variances—simulated pushes, shifting floor friction, and momentum changes—to train the model against the chaos of the real world. The resulting reinforcement learning model was condensed into a highly efficient ONNX policy and deployed directly to the physical robot. This edge policy processes live IMU and joint telemetry to output immediate, stabilized motor commands. Reaching this scale of simulation volume is the precise engineering mechanism that allows control policies to handle unstructured physical deployment. To support the research, Unitree has open-sourced the underlying RL code on GitHub. Blog post : https://lnkd.in/g4-gWzTP #Robotics #PhysicalAI #ReinforcementLearning #MuJoCo #GoogleCloud #IsaacSim #Engineering