NCP‐MCA_7 - itnett/FTD02H-N GitHub Wiki

Let's continue with the detailed cheat sheet for Section 2: Deploy and Configure Self-Service and Related Components of the Nutanix NCP-MCA 6.5 exam.

📝 Nutanix NCP-MCA 6.5 Exam Cram Sheet (Continued)

📚 Section 2: Deploy and Configure Self-Service and Related Components

📘 Objective 2.1: Given a Scenario, Create a Blueprint to Deploy Infrastructure and Applications Using Self-Service

Key Knowledge Areas:
- Creating a Self-Service Blueprint:
  - Blueprints are templates defining the infrastructure, applications, and configurations required for deployment. Start by identifying the components needed for deployment (e.g., VMs, networks, security groups) and their dependencies.
- Creating a Substrate:
  - Substrate refers to the underlying infrastructure (e.g., AHV, AWS, Azure) where the blueprint will be deployed. Configure the substrate settings to match the environment, ensuring compatibility and optimal performance.
- Creating Day Two Actions:
  - Day Two Actions are tasks performed after the initial deployment, such as scaling operations, patching, or updates. Define these actions in the blueprint to ensure smooth post-deployment management.
- Creating a Task:
  - Determine which task type (e.g., HTTP, VM, SSH) to use based on the script language or function needed for deployment.
- Configuring Install/Uninstall Packages:
  - Set up tasks to install or uninstall packages using supported script languages (e.g., Bash, PowerShell). Ensure scripts are compatible with the OS and meet prerequisites.
Practical Examples:
- 💡 Creating a Single-VM Blueprint:
  - Use Calm to create a blueprint for deploying a single VM with predefined CPU, RAM, disk, and network settings. Add an HTTP task to configure the VM upon deployment.
- 🔄 Creating a Multi-VM Blueprint:
  - Design a blueprint for deploying a multi-tier application (e.g., web server, app server, database). Use tasks to define the deployment order and dependencies.
- 🛠️ Setting Up Day Two Actions:
  - Configure a Day Two Action for scaling out a web server farm when traffic exceeds a certain threshold.
Tools to Know:
- Blueprint Designer: A visual tool in Calm to design and configure blueprints.
- Macros and Variables: Reusable parameters for dynamic content within blueprints.
- Calm Scripts: Use Bash, PowerShell, or other supported languages for custom tasks.
Dos and Don’ts:
- ✅ Do:
  - Use Dynamic Macros to define variable content (e.g., IP addresses, hostnames) that changes per deployment.
  - Define Clear Task Dependencies to ensure tasks execute in the correct sequence.
  - Test Blueprints in a Sandbox Environment to validate configurations and avoid issues in production.
- ❌ Don’t:
  - Ignore Compatibility Checks: Always check substrate compatibility with the blueprint.
  - Forget Day Two Actions: Ensure post-deployment tasks are configured for effective management and maintenance.
References:

📘 Objective 2.2: Demonstrate an Understanding of Self-Service Managed Infrastructure and Applications

Key Knowledge Areas:
- Scaling Out and Scaling In:
  - Scale Out: Add more resources (e.g., VMs, storage) to handle increased demand. Define triggers (e.g., CPU usage threshold) to automate scaling.
  - Scale In: Remove resources when demand decreases to optimize costs and performance.
- Retiring a Managed Application:
  - Retire an application when it is no longer needed. Follow a controlled process to decommission resources, ensure data integrity, and maintain compliance.
- Managing Applications:
  - Use the Self-Service Portal to manage the lifecycle of deployed applications, including updates, monitoring, and scaling.
- Running a Task:
  - Execute specific tasks (e.g., backups, patch updates) using the Self-Service interface or through automated scripts.
Practical Examples:
- 💡 Scaling Out a Web Server Farm:
  - Configure a blueprint with a scale-out action to add new web server VMs when CPU utilization exceeds 80% for 5 minutes.
- 🔄 Retiring an Application:
  - Use the Self-Service Portal to safely decommission a development environment, ensuring all associated resources are removed and data is backed up.
Tools to Know:
- Self-Service Manage Tab: Interface for managing deployed applications and performing day-to-day operations.
- Scaling Profiles: Set up profiles to define scaling behavior for applications.
- Task Runner: Tool for executing custom tasks on-demand.
Dos and Don’ts:
- ✅ Do:
  - Define Clear Scaling Triggers to automate resource adjustments based on demand.
  - Use the Manage Tab to monitor application performance and make adjustments as needed.
- ❌ Don’t:
  - Neglect Resource Cleanup: Always clean up resources after retiring an application to avoid unnecessary costs.
  - Overlook Application Monitoring: Regularly monitor application health to ensure optimal performance.
References:

📘 Objective 2.3: Identify Required Configuration Settings for a Self-Service Deployment

Key Knowledge Areas:
- Configuring Providers:
  - Set up provider accounts (e.g., AHV, AWS, Azure) in Calm to enable Self-Service deployments. Configure access credentials, API endpoints, and permissions for each provider.
- Setting Up Environments:
  - Define environments in Self-Service to specify which accounts and resources (e.g., networks, storage) can be used for deployments.
- Marketplace Capabilities:
  - Utilize the Nutanix Marketplace to deploy pre-approved applications and services. Understand how to publish and manage applications in the Marketplace.
- Configuring Endpoints:
  - Set up endpoints required for connecting to external services or executing tasks.
- Creating Library Items:
  - Develop reusable components (e.g., scripts, templates) stored in the library for consistent deployment practices.
Practical Examples:
- 💡 Configuring Provider Accounts:
  - Set up an AWS provider account in Calm with appropriate IAM roles and API keys for automated deployments.
- 📚 Creating a Library Item:
  - Develop a reusable script for initializing Linux VMs and save it as a library item for future use in multiple blueprints.
Tools to Know:
- Provider Account Settings: Interface for configuring provider accounts in Calm.
- Marketplace Manager: Tool for managing applications available for deployment from the Nutanix Marketplace.
- Endpoint Configuration: Interface to set up and manage endpoints for external service connectivity.
Dos and Don’ts:
- ✅ Do:
  - Use Marketplace Applications to save time and ensure deployment consistency.
  - Set Up Endpoints Correctly to avoid connectivity issues during deployment.
- ❌ Don’t:
  - Use Hardcoded Credentials: Always use secure methods (e.g., environment variables) for managing credentials.
  - Ignore Environment Requirements: Ensure environments are configured with the correct resources and permissions.
References:

📘 Objective 2.4: Identify Common Blueprint Features

Key Knowledge Areas:
- Built-in Macros and Tasks:
  - Use built-in macros (e.g., @@{calm_array}@@) to dynamically reference variables and system properties within blueprints.
- Action/Task Dependencies:
  - Configure tasks to run in a specific order based on their dependencies. Ensure tasks do not execute until their prerequisites are met.
- Authentication Credentials:
  - Include credentials in blueprints using secure methods like cloud-init for Linux or sysprep for Windows.
- Application Profiles:
  - Define different application profiles (e.g., dev, test, prod) to tailor deployments for specific environments.
Practical Examples:
- 💡 Using Built-in Macros:
  - Implement macros in a blueprint to dynamically assign IP addresses to VMs during deployment.
- 🔍 Configuring Task Dependencies:
  - Ensure database setup tasks are completed before deploying application servers in a multi-tier deployment.
Tools to Know:
- Blueprint Configurations: Learn to set up and manage blueprint configurations, including tasks, dependencies, and macros.
- Credential Manager: Securely store and reference credentials within blueprints.
- Macros Overview: Understand the syntax and usage of macros in Calm.
Dos and Don’ts:
- ✅ Do:
  - Use Macros to Enhance Flexibility: Leverage built-in macros to handle dynamic variables during deployment.
  - Manage Dependencies Carefully: Define task dependencies to prevent deployment failures.
- ❌ Don’t:
  - Hardcode Credentials: Always use secure methods for handling sensitive information.
  - Overlook Profile Customization: Tailor application profiles to match specific environment needs.
References:

📘 Objective 2.5: Identify Common Runbook Features

Key Knowledge Areas:
- Task Types:
  - Understand different task types in runbooks (e.g., SSH, REST, HTTP) and when to use them for specific operations.
- Built-in Macros, Tasks, and Dependencies:
  - Use built-in macros and define dependencies between tasks to ensure proper execution flow.
Practical Examples:
- 💡 Using SSH Tasks in Runbooks:
  - Automate a patching process by running SSH commands on a group of Linux servers.
- 🛠️ Configuring Task Dependencies in Runbooks:
  - Set dependencies to ensure backup tasks are completed before applying updates to a database server.
Tools to Know:
- Runbooks in Calm: Interface for creating and managing automation workflows.
- Task Automation: Define tasks in runbooks and configure execution order and dependencies.
- Macros in Runbooks: Use macros for dynamic content and operations within runbooks.
Dos and Don’ts:
- ✅ Do:
  - Utilize Different Task Types to handle various operational requirements (e.g., HTTP for API calls, SSH for remote commands).
  - Define Clear Dependencies to ensure tasks execute in the correct order.
- ❌ Don’t:
  - Neglect Error Handling: Include error-handling steps to manage task failures.
  - Use Static Content: Leverage macros for dynamic and reusable runbooks.
References:

Next Steps:

This detailed cheat sheet covers the key concepts, practical examples, tools, dos and don'ts, and references for Section 2 of the Nutanix NCP-MCA 6.5 exam. Let me know if you'd like to continue with Section 3 or any other specific areas where you would like more in-depth information!