Free Practice Questions for Cisco 200-901 Exam

Rate limiting is a technique used to control the amount of incoming and outgoing traffic to or from a network. It restricts the number of API requests a user can make within a specified time window, protecting the application from being overwhelmed by too many requests at once.

Definition and Purpose: Rate limiting sets a threshold for the number of requests a user or system can make in a given timeframe (e.g., 100 requests per minute).

Implementation: Developers can implement rate limiting using various strategies such as token buckets or fixed windows.

Benefits: This constraint helps prevent abuse, reduces server load, and ensures the application remains available and performant even during high traffic periods or attacks.

References:

Rate Limiting and Throttling in APIs: Rate Limiting

The block of code that correctly completes the script should handle timeout exceptions and print the error, as well as print the response body if the HTTP status code is 200. Option A achieves this:

import requests

url = 'https://api.meraki.com/api/v0/networks/net1/httpServers '

headers = { 'Accept': 'application/json' }

response = requests.get(url=url, headers=headers, verify=False, timeout=5)

try:

response = requests.get(url, headers=headers, verify=False, timeout=5)

response.raise_for_status()

except requests.Timeout as e:

print("Timeout Error: {}".format(e))

if response.status_code == 200:

print(response.text)

This code makes a GET request to the specified URL, handles the timeout exception by printing a message, and prints the response body if the status code is 200.

References:

Requests: Handling Timeouts

Python Requests: Response Status Code

Infrastructure as Code (IaC) principles emphasize the use of code to manage and provision computing infrastructure. The key situations that align with IaC principles include:

Easily reproducible systems: Infrastructure can be recreated consistently across different environments using code, ensuring that systems are reliable and predictable.

Repeatable processes: Using scripts and configuration files to automate infrastructure setup and management ensures that processes can be repeated accurately and efficiently.

References:

Infrastructure as Code (IaC) Principles

Cisco DevNet Associate Certification Guide

The control plane in a network device is responsible for routing and signaling. Protocols such as BGP (Border Gateway Protocol) and OSPF (Open Shortest Path First) are integral to the control plane.

BGP (Border Gateway Protocol): BGP is used for exchanging routing information between autonomous systems on the internet, making it a crucial control plane protocol.

OSPF (Open Shortest Path First): OSPF is an interior gateway protocol used for routing within an autonomous system, also part of the control plane.

References:

BGP and OSPF Protocol Details: BGP, OSPF

Refer to the exhibit which shows a sequence diagram illustrating a client-server interaction. The correct sequence of steps that match the code snippet is as follows:

Step 1: POST /events - The client posts an event to the server.

Step 2: GET /messages/<messageId> - The client retrieves the message details from the server using the message ID.

Step 3: Response /messages/<messageId> - The server responds with the message details.

Step 4: GET /team-memberships?teamId=<teamId> - The client retrieves team membership details using the team ID.

Step 5: POST /message - The client posts a message.

Step 6: Response /message - The server responds with the message confirmation.

The correct code snippet represents the sequence diagram correctly:

@flask_app.route('/events', methods=['POST'])

def webex_teams_webhook_events():

json_data = request.json['data']

response = requests.get(MESSAGE_URL + json_data['id'], headers=headers)

if response.json()['text'] == 'Alert':

response = requests.get(TEAM_MEMBERSHIPS_URL, headers=headers, params=params)

for info in response.json()['items']:

data = {'personId': info['personId'], 'text': 'Alert'}

REST APIs are designed around resources that are identified by URLs. Operations are performed on these resources using standard HTTP methods like GET, POST, PUT, and DELETE. In contrast, RPC (Remote Procedure Call) APIs are designed around actions or operations, where the focus is on invoking methods or functions rather than manipulating resources.

Version control systems (VCS) are essential for managing changes to code and files in a project. They track all modifications, enabling multiple users to work collaboratively while maintaining a history of changes.

Tracking Changes: VCS keeps a detailed history of changes made to files, including who made the change and when.

Collaboration: Multiple users can work on the same project simultaneously without overwriting each other's work.

Reverting Changes: It allows reverting to previous versions if a mistake is made.

Option B is correct as it highlights the primary benefit of version control—keeping track of all changes to the files.

1 – B, 2 – E, 3 – C, 4 – D, 5 – A

This Python script uses the Cisco DNA Center API to retrieve a list of network devices. The steps are:

Import the required libraries: requests for making HTTP requests and json for handling JSON data.

Define the API endpoint URL for retrieving network devices from Cisco DNA Center.

Set up the request headers, including the content type and the authentication token (X-Auth-Token).

Send a GET request to the API endpoint.

Check the response status code to ensure the request was successful.

If successful, parse and print the JSON response containing the list of network devices. Otherwise, print an error message.

Test-Driven Development (TDD) is a software development approach where tests are written before the code that needs to be tested.

TDD Process:

Write a Test: Start by writing a test for a new feature or functionality.

Run the Test: Run the test, which should fail initially since the code hasn’t been written yet.

Write Code: Write the minimum amount of code required to pass the test.

Run Tests Again: Run the tests again to ensure they pass.

Refactor: Refactor the code while ensuring the tests still pass.

Advantages:

Early Bug Detection: Bugs are detected early in the development cycle.

Better Design: Promotes writing cleaner, more modular code.

Documentation: The tests themselves serve as documentation for the code.

Writing and running tests before writing the actual code ensures that the code meets the specified requirements and functions correctly.

References:

TDD Overview: Test-Driven Development