# Junos Automation Stack and DevOps Concepts ### **Core Concepts** The **Junos Automation Stack** is a set of tools, technologies, and methodologies provided by Juniper Networks to automate the management and operation of their network devices. Automation in networking reduces manual effort, prevents human errors, and ensures that tasks are done consistently and efficiently. - **Why Automation?** - Traditional manual configuration and management of devices can be time-consuming and error-prone. - Automation allows repetitive tasks, such as device configuration, updates, and monitoring, to be done automatically. - It improves reliability, speeds up deployment, and frees up time for more complex tasks. - **How Junos Automation is Special:** - Junos devices come with built-in tools and APIs that make automation easier. - These tools work seamlessly with DevOps methodologies (a set of practices combining development and operations for efficiency). ### **Automation Technologies in Junos** #### **1. On-box Automation (Automation on the Device)** This type of automation runs directly on the Junos device itself. No additional software or servers are needed; the device does all the work. - **Supported Scripting Languages:** - **SLAX (Script Language for XML):** - A lightweight scripting language designed specifically for Junos. - SLAX is based on XML, so it is structured and easy for machines to process. - Example: Writing a script that checks if an interface goes down and sends an alert. - **Python:** - Python is a popular and powerful programming language that Junos supports for on-device scripting. - It allows more complex tasks to be automated. - Example: Writing a Python script to collect interface statistics and save them for analysis. - **Benefits of On-box Automation:** - No need for external tools or servers; everything is handled by the device. - Scripts can react to real-time events on the device. - **Example Scenario:** Imagine you want to monitor an interface on a router. If the interface goes down, the script can log the event and notify you via email. #### **2. Off-box Automation (Automation from an External System)** This type of automation is run on an external system (e.g., a laptop, server, or cloud platform). The external system communicates with the Junos device using APIs (Application Programming Interfaces) or CLI (Command-Line Interface). - **How It Works:** - The script or program is executed on the external system. - It uses APIs like NETCONF or REST to interact with the Junos device. - **When to Use Off-box Automation:** - Managing multiple devices simultaneously. - Complex tasks that require significant processing power or integration with other systems. - Centralized automation where one server controls multiple network devices. - **Use Case Example:** Suppose you have 100 network devices in your data center. Instead of logging into each device to make a configuration change, you can use a single script running on your computer to push changes to all devices simultaneously. #### **3. Junos Telemetry Interface (JTI)** Telemetry refers to the collection of real-time data from devices for monitoring and analysis. - **What is JTI?** - A feature of Junos that provides streaming data from devices. - It sends information about the device’s performance, such as CPU usage, interface traffic, or errors, to an external monitoring system. - **Data Output Formats:** - **gRPC:** A high-performance protocol that allows efficient data streaming. - **UDP:** A lightweight protocol for sending data. - **Why JTI is Important:** - Instead of checking devices manually or using old-fashioned polling methods, JTI streams data in real time, making it more efficient. - It helps in early detection of network issues. - **Example Use Case:** Imagine you want to monitor traffic levels on an interface in real time. JTI can stream the data to a monitoring system like Grafana, which visualizes the traffic as a live graph. ### **DevOps Principles** DevOps practices are becoming essential for network automation, combining **Development** and **Operations** for better efficiency. Here are three key principles in DevOps: #### **1. CI/CD (Continuous Integration and Continuous Delivery)** - **Continuous Integration:** Automatically test and validate configuration changes before they are applied to devices. - **Continuous Delivery:** Ensure changes can be safely deployed to devices with minimal manual intervention. - **How it helps:** Prevents misconfigurations and ensures new changes don’t disrupt the network. #### **2. Infrastructure as Code (IaC)** - **What is IaC?** Treat your network configuration like code—store it in files and use automation tools to apply it. - **Tools:** Use tools like Ansible to write playbooks (scripts) that automate device configuration. #### **3. Version Control** - Use tools like **Git** to track changes to configurations. - Easily roll back to a previous version if something goes wrong. - Collaborate with team members by sharing configuration changes. ### **Real-world Applications of Junos Automation Stack** 1. **Automating Software Upgrades:** - Use scripts to schedule and perform software upgrades on devices without manual intervention. 2. **Monitoring Traffic Flows:** - Set up telemetry to monitor interface traffic and send alerts if traffic exceeds a certain threshold. 3. **Configuration Testing with Jenkins Pipelines:** - Use a CI/CD pipeline with Jenkins to automatically test new configurations before applying them to production devices. ### **Step-by-step Example: Automating Interface Monitoring** #### Goal: Monitor an interface and send an alert if it goes down. 1. **Write a Python Script:** - Use Junos PyEZ to interact with the device. ```python from jnpr.junos import Device from jnpr.junos.exception import ConnectError def monitor_interface(device_ip, username, password): try: with Device(host=device_ip, user=username, passwd=password) as dev: interfaces = dev.rpc.get_interface_information() for interface in interfaces.iter('physical-interface'): name = interface.findtext('name') status = interface.findtext('oper-status') if status != 'up': print(f"Alert: {name} is down!") except ConnectError as err: print(f"Cannot connect to device: {err}") monitor_interface('192.168.1.1', 'admin', 'admin123') ``` 2. **Run the Script:** - Schedule it to run periodically using a cron job or similar tool. 3. **Receive Alerts:** - The script will check the status of interfaces and notify you if any go down. By understanding and applying the Junos Automation Stack and DevOps concepts, you can streamline your network management, reduce errors, and save time. --- # NETCONF/XML API ### **NETCONF Overview** NETCONF (Network Configuration Protocol) is a protocol designed specifically for managing network devices. It enables automation by allowing programmatic interaction with devices to configure, monitor, and retrieve information securely and efficiently. #### **Key Features of NETCONF:** 1. **Protocol Type:** - NETCONF is an **RPC-based protocol** (Remote Procedure Call). This means it works by sending requests (like "get configuration") and receiving responses from the device. 2. **Transport Layer:** - NETCONF uses **SSH** (Secure Shell) to securely transmit data between the client and the network device. This ensures that the data is encrypted and safe from unauthorized access. 3. **Data Model:** - The core data format in NETCONF is **XML** (Extensible Markup Language). XML is structured and hierarchical, making it easy to organize and exchange data. 4. **Applications:** NETCONF is used in: - **Configuration Management:** Modify and save configurations on network devices. - **State Retrieval:** Query devices to get operational information like interface statuses or routing tables. - **Event Notifications:** Receive alerts or updates about changes in the network. ### **Core NETCONF Operations** NETCONF operations are defined as specific actions or procedures that a client can perform on a network device. Below are the most important ones: #### **1. Session Management** Before performing any action, a NETCONF session must be established between the client (e.g., a script or automation tool) and the device. This session is initiated over an SSH connection. - **How to Start a Session:** - Use the following command to connect: ```bash ssh -s netconf user@192.168.1.1 ``` - The `-s netconf` flag specifies that the SSH connection should be used for NETCONF. - **Session Lifecycle:** - **Open:** Establish a session. - **Perform Operations:** Execute RPC calls. - **Close:** End the session gracefully. #### **2. RPC Calls (Remote Procedure Calls)** NETCONF operations are carried out through **RPCs**, which are requests sent by the client to the device. The device processes the request and sends back a response. - **Common RPC Calls:** 1. **``**: Retrieve operational state information (e.g., interface status, routing tables). 2. **``**: Fetch the current configuration from the device. 3. **``**: Modify the device’s configuration. - **Example RPC Request and Response:** **Request (XML format):** ```xml

``` **Response (from the device):** ```xml

my-device

``` - **Explanation:** - The client requested the candidate configuration (a temporary configuration before committing changes). - The device replied with the system hostname configuration. #### **3. Configuration Locking and Unlocking** - **Why Locking is Needed:** When multiple clients or administrators interact with the same device, configuration conflicts can arise. Locking ensures only one client has access to modify configurations at a time. - **NETCONF Locking Workflow:** 1. **Lock Configuration:** - Issue a lock command before making changes. - Example RPC for locking: ```xml ``` 2. **Make Changes:** Perform your configuration edits. 3. **Unlock Configuration:** Release the lock to allow others to access the configuration. - **Benefits:** - Prevents simultaneous edits that could overwrite each other. - Ensures consistency and avoids configuration corruption. ### **XML’s Role in NETCONF** XML is a key component of NETCONF, serving as the data format for all communications between the client and the device. #### **Features of XML:** 1. **Structured Data:** - XML uses a hierarchical format with nested tags, making it easy to organize and understand. For example: ```xml

my-device

``` - This structure clearly shows that "host-name" is part of the "system" configuration. 2. **Extensibility:** - XML can be extended using schemas, allowing it to support custom functionality. 3. **Human-Readable and Machine-Readable:** - XML is easy for both humans and machines to parse, making it ideal for configuration management. ### **Use Cases for NETCONF** #### **1. Automating Device State Retrieval** Scripts can use NETCONF to automatically fetch the operational state of a device, such as: - Interface status (e.g., is an interface up or down?). - CPU usage or memory statistics. - Routing tables or firewall rules. **Python Example:** ```python from ncclient import manager with manager.connect(host="192.168.1.1", port=830, username="admin", password="admin123", hostkey_verify=False) as m: rpc_reply = m.get(filter=('subtree', '')) print(rpc_reply.xml) ``` - **Explanation:** - The script connects to the device using the `ncclient` library. - It retrieves information about all interfaces on the device. #### **2. Performing Configuration Rollbacks** NETCONF allows you to revert to a previous configuration if something goes wrong. - **Workflow:** 1. Fetch the current configuration using ``. 2. Save a backup of the configuration. 3. Apply new changes using ``. 4. If an error occurs, reapply the saved configuration using ``. ### **Summary** NETCONF, combined with XML, is a powerful protocol for managing and automating network devices. It allows you to: - Securely communicate with devices over SSH. - Retrieve device state and configuration data. - Modify configurations programmatically. - Avoid conflicts through configuration locking. By learning NETCONF, you gain the ability to interact with network devices in a standardized and efficient way, enabling you to automate repetitive tasks and build robust network automation solutions. --- # Data Serialization This topic is critical for understanding how data is structured, transferred, and processed in network automation workflows. ### **Concept of Data Serialization** **What is Data Serialization?** Serialization is the process of converting complex data structures (such as dictionaries, lists, or objects in programming) into a format that can be easily stored or transmitted. In network automation, serialization is used to: - Standardize data representation for easy sharing between systems. - Enable scripts or tools to interact with network devices in a consistent manner. - Store or export data in a readable and reusable format. **Why is Serialization Important in Network Automation?** - Network devices and automation tools often communicate using serialized data formats. - Configuration management systems rely on serialization to represent and apply configurations. - Automation frameworks like Ansible, REST APIs, and Python scripts depend heavily on serialized data formats. ### **Serialization Formats** Two popular serialization formats in network automation are **JSON** and **YAML**. Both are lightweight, readable, and widely used, but each has unique characteristics and use cases. #### **1. JSON (JavaScript Object Notation)** **Overview:** JSON is a text-based format designed to store and exchange data in a structured and easy-to-parse manner. It represents data as a set of key-value pairs and arrays. **Syntax Structure:** - JSON uses curly braces `{}` to enclose objects (key-value pairs). - Square brackets `[]` are used for arrays (lists of values). - Strings, numbers, booleans, and null values are all valid data types. **Example:** ```json { "interface": { "name": "ge-0/0/0", "status": "up" } } ``` **Advantages of JSON:** - **Lightweight:** Compact representation makes it efficient for data transfer. - **Widely Supported:** Supported by nearly all programming languages and APIs. - **Easy to Parse:** Many libraries and frameworks provide built-in JSON parsers. **Applications of JSON:** - **REST API Data Exchange:** REST APIs commonly use JSON as the default format for sending and receiving data. - Example REST API response: ```json { "hostname": "router1", "interfaces": [ { "name": "ge-0/0/0", "status": "up" }, { "name": "ge-0/0/1", "status": "down" } ] } ``` - **Data Processing in Python:** Python has built-in support for JSON through the `json` module. Example: ```python import json data = '{"interface": {"name": "ge-0/0/0", "status": "up"}}' parsed_data = json.loads(data) # Convert JSON string to Python dictionary print(parsed_data["interface"]["name"]) # Output: ge-0/0/0 ``` #### **2. YAML (YAML Ain’t Markup Language)** **Overview:** YAML is a human-readable data serialization format often used for configuration files. Unlike JSON, YAML uses indentation to define data structure, making it more visually intuitive. **Syntax Structure:** - Indentation is used to represent data hierarchy (no curly braces or quotes are needed unless necessary). - Key-value pairs are separated by colons (`:`). **Example:** ```yaml interface: name: ge-0/0/0 status: up ``` **Advantages of YAML:** - **Human-Readable:** Easier to read and write, especially for configuration files. - **Supports Comments:** Comments start with `#`, making it easy to document configurations. - **Widely Used in Automation Tools:** YAML is the default format for many tools, including Ansible playbooks. **Applications of YAML:** - **Writing Playbooks in Ansible:** YAML is used to define tasks, configurations, and workflows in Ansible. Example: ```yaml - name: Configure interface junos_config: lines: - set interfaces ge-0/0/0 description "Uplink" - set interfaces ge-0/0/0 unit 0 family inet address 192.168.1.1/24 commit: yes ``` - **Configuration Files:** YAML is often used to define configuration files for cloud infrastructure, container management (e.g., Kubernetes), and automation workflows. ### **Relation to Automation** Serialization plays a critical role in network automation by enabling efficient data representation, transmission, and processing. Let’s explore its importance in two main areas: #### **1. Configuration Generation** Automation often involves generating and applying configurations to network devices. Serialized formats like JSON and YAML allow: - **Templates:** Use a base template and fill in device-specific values dynamically. - **Batch Configuration:** Apply standardized configurations across multiple devices. **Example in Python (Using JSON):** ```python import json # Define configuration as a Python dictionary config = { "interface": { "name": "ge-0/0/0", "description": "Uplink Interface", "ip_address": "192.168.1.1/24" } } # Serialize configuration to JSON format config_json = json.dumps(config, indent=2) print(config_json) ``` **Output:** ```json { "interface": { "name": "ge-0/0/0", "description": "Uplink Interface", "ip_address": "192.168.1.1/24" } } ``` #### **2. Data Exchange** Serialized formats allow easy communication between automation tools and devices. For example: - **REST API Calls:** JSON is used to send requests and parse responses. - **Telemetry Data Processing:** YAML or JSON is used to represent the data stream from devices for monitoring and analysis. **Real-world Scenario:** - You need to monitor interface status and send alerts if an interface goes down. - **Step 1:** Collect interface data from the device in JSON format using a REST API. - **Step 2:** Parse the JSON response using Python to check for any issues. - **Step 3:** Use YAML to define an alert configuration that specifies how and where to send notifications. ### **Summary** Serialization is a foundational concept in network automation. Understanding how JSON and YAML work enables you to: - **Standardize configurations** across devices. - **Integrate automation tools** with network systems. - **Simplify data processing** for monitoring and troubleshooting. Both formats are indispensable in modern automation workflows. JSON is ideal for APIs and programming, while YAML excels in configuration management and human-readable tasks. By mastering these formats, you can enhance your automation scripts and workflows significantly. --- # Python/PyEZ This topic explains how Python and the PyEZ library can be used for network automation with Junos devices. ### **Role of Python** Python is widely recognized as the primary programming language for network automation because of its simplicity, readability, and powerful libraries. Juniper Networks provides the **PyEZ** library, specifically designed to automate interactions with Junos devices. - **Why Use Python for Network Automation?** - **Ease of Use:** Python has a simple syntax that makes it beginner-friendly. - **Extensive Libraries:** Libraries like PyEZ, Paramiko, and Netmiko simplify device interaction. - **Cross-Platform Compatibility:** Python works across different operating systems and integrates well with APIs and automation tools. - **What is PyEZ?** - PyEZ is a Python library provided by Juniper Networks. - It simplifies common tasks like device connection, configuration management, and state retrieval. - PyEZ abstracts complex network protocols (like NETCONF) into easy-to-use Python methods. ### **PyEZ Components** The PyEZ library is modular, with different components for specific tasks. Here are the three most commonly used components: #### **1. Device Class** The **Device** class is the foundation of PyEZ. It establishes a connection to a Junos device and allows interaction with it. - **Steps to Connect to a Device:** 1. Import the `Device` class from PyEZ. 2. Create an instance of `Device` with the device’s IP, username, and password. 3. Open the connection. 4. Access device information (like hostname, model, or software version). 5. Close the connection when done. - **Example Code:** ```python from jnpr.junos import Device # Define device connection details dev = Device(host='192.168.1.1', user='admin', passwd='password') # Open a connection to the device dev.open() # Print device facts (basic information like hostname, version, etc.) print(dev.facts) # Close the connection dev.close() ``` - **Output Example:** ```plaintext {'hostname': 'router1', 'model': 'MX240', 'version': '20.2R3'} ``` - **Benefits:** - Simplifies the process of connecting to Junos devices. - Provides built-in methods to retrieve device information. #### **2. Configuration Management** The **Config** class in PyEZ allows you to: - Load configurations (in various formats like `set`, `xml`, or `json`). - Commit changes to the device. - Roll back configurations if necessary. - **Steps for Configuration Management:** 1. Import the `Config` utility from PyEZ. 2. Open a configuration session with the device. 3. Load new configurations. 4. Commit the changes. - **Example Code:** ```python from jnpr.junos.utils.config import Config from jnpr.junos import Device # Connect to the device dev = Device(host='192.168.1.1', user='admin', passwd='password') dev.open() # Open a configuration session with Config(dev) as cu: # Load a configuration in 'set' format cu.load('set system host-name my-device', format='set') # Commit the changes cu.commit() # Close the connection dev.close() ``` - **Explanation:** - The script changes the hostname of the device to `my-device`. - The `with` statement ensures the configuration session is properly closed after the operation. - **Benefits:** - Easy to push configurations to devices. - Supports error checking and rollbacks. #### **3. Operational Commands** The **Command** class lets you execute operational (non-configuration) commands on Junos devices. These are typically "show" commands used to retrieve device status, logs, or statistics. - **Steps for Running Commands:** 1. Import the `Command` utility from PyEZ. 2. Connect to the device. 3. Execute a command and retrieve the output. - **Example Code:** ```python from jnpr.junos.utils.command import Command from jnpr.junos import Device # Connect to the device dev = Device(host='192.168.1.1', user='admin', passwd='password') dev.open() # Execute a 'show version' command output = Command(dev).execute('show version') # Print the command output print(output) # Close the connection dev.close() ``` - **Output Example:** ```plaintext Hostname: router1 Model: MX240 Junos: 20.2R3 ``` - **Benefits:** - Simplifies retrieving operational data. - Outputs data in a structured format (easy to process programmatically). ### **Real-world Applications** Here are practical scenarios where Python and PyEZ can be used in network automation: #### **1. Automating Configuration Backups** - Use PyEZ to connect to devices and retrieve their running configuration. - Save the configurations to a file or database for backup purposes. **Example:** ```python from jnpr.junos import Device # Connect to the device dev = Device(host='192.168.1.1', user='admin', passwd='password') dev.open() # Retrieve configuration config = dev.rpc.get_config() # Save the configuration to a file with open('backup.xml', 'w') as backup_file: backup_file.write(config.xml) # Close the connection dev.close() ``` #### **2. Periodically Retrieving Device States** - Schedule scripts to run at regular intervals and retrieve operational data like interface status, CPU usage, or system uptime. **Example:** ```python from jnpr.junos import Device def check_interface_status(device_ip, user, password): # Connect to the device dev = Device(host=device_ip, user=user, passwd=password) dev.open() # Get interface information interfaces = dev.rpc.get_interface_information() print(interfaces) # Close the connection dev.close() # Periodically check the interface status check_interface_status('192.168.1.1', 'admin', 'password') ``` ### **Summary** PyEZ provides a straightforward and Pythonic way to automate Junos device operations. Its modular components make tasks like device connection, configuration management, and state retrieval simple and efficient. By using PyEZ, you can: - Streamline routine network management tasks. - Ensure consistency and reduce human error. - Easily scale automation workflows for large networks. --- # REST API REST API is a vital component of modern network automation. It provides a simple, lightweight, and flexible way to interact with devices over HTTP. ### **REST API Overview** #### **What is a REST API?** REST (Representational State Transfer) is a standard architecture for web services that allows systems to communicate over HTTP. REST APIs enable scripts or applications to interact with network devices by sending requests and receiving responses. #### **Key Features of REST API:** - **Lightweight:** REST APIs use standard HTTP methods and formats, requiring minimal overhead. - **Stateless:** Each interaction between the client and the server is independent. - **Standardized Methods:** REST APIs rely on standard HTTP operations like GET, POST, PUT, and DELETE. #### **Common HTTP Methods in REST API:** - **GET:** Retrieves information or resources from a device. - **POST:** Creates new resources (e.g., adding a new configuration). - **PUT:** Updates existing resources. - **DELETE:** Removes resources. #### **Data Formats in REST API:** - **JSON (JavaScript Object Notation):** Commonly used for REST APIs because of its lightweight and easy-to-read structure. - **XML (Extensible Markup Language):** Also supported but less frequently used in modern implementations. ### **Junos REST API** The Junos REST API allows you to interact with Junos OS devices using RESTful principles. You can retrieve configuration data, send operational commands, or make configuration changes programmatically. #### **1. Enabling REST API on a Junos Device** Before using the REST API, it must be enabled on the Junos device. **Command to Enable REST API:** ```bash set system services rest ``` This command configures the device to accept REST API requests. #### **2. Accessing REST API with curl** **What is curl?** - A command-line tool used to send HTTP requests and interact with REST APIs. **Example: Retrieving Interface Configuration** ```bash curl -X GET -u admin:admin123 http:///rest/configuration/interfaces ``` **Explanation:** - `-X GET`: Specifies the HTTP method (GET in this case). - `-u admin:admin123`: Provides authentication credentials (username and password). - `http:///rest/configuration/interfaces`: The REST API endpoint for retrieving interface configuration. **Example Output:** ```json { "interfaces": [ { "name": "ge-0/0/0", "status": "up" }, { "name": "ge-0/0/1", "status": "down" } ] } ``` #### **3. Using REST API in Python** Python provides a more programmatic and flexible way to interact with REST APIs, often using libraries like `requests`. **Example: Retrieve Interface Configuration** ```python import requests # Define the REST API endpoint and authentication details url = "http://192.168.1.1/rest/configuration/interfaces" response = requests.get(url, auth=('admin', 'admin123')) # Check if the request was successful if response.status_code == 200: # Parse and print the JSON response print(response.json()) else: print(f"Error: {response.status_code}") ``` **Explanation:** 1. `requests.get`: Sends an HTTP GET request to the REST API endpoint. 2. `auth=('admin', 'admin123')`: Provides authentication credentials. 3. `response.json()`: Parses the JSON response returned by the API. **Example Output:** ```json { "interfaces": [ { "name": "ge-0/0/0", "status": "up" }, { "name": "ge-0/0/1", "status": "down" } ] } ``` ### **Use Cases** REST APIs are versatile and can be used in various network automation scenarios: #### **1. Developing Management Tools for Network Devices** - REST APIs allow you to create custom tools for tasks like: - Viewing network device inventory. - Pushing new configurations to devices. - Monitoring device health and performance metrics. **Example: Automating Configuration Backup** Use Python and REST API to retrieve and save configurations: ```python import requests # Retrieve the running configuration url = "http://192.168.1.1/rest/configuration" response = requests.get(url, auth=('admin', 'admin123')) # Save the configuration to a file if response.status_code == 200: with open('config_backup.json', 'w') as file: file.write(response.text) else: print(f"Error: {response.status_code}") ``` #### **2. Integrating Monitoring and Automation Systems** - REST APIs can be used to integrate Junos devices with monitoring platforms like Grafana or automation tools like Ansible. **Example: Monitoring Interface Status** - Create a script to periodically check interface status and alert if any interface is down. **Python Example:** ```python import requests import time def monitor_interface_status(): url = "http://192.168.1.1/rest/configuration/interfaces" while True: response = requests.get(url, auth=('admin', 'admin123')) if response.status_code == 200: interfaces = response.json().get("interfaces", []) for interface in interfaces: if interface["status"] != "up": print(f"Alert: {interface['name']} is down!") else: print(f"Error: {response.status_code}") # Wait for 60 seconds before the next check time.sleep(60) monitor_interface_status() ``` ### **Summary** The Junos REST API is a powerful tool for interacting with network devices. By using standard HTTP methods (GET, POST, PUT, DELETE) and data formats like JSON or XML, you can programmatically manage configurations, monitor device states, and develop robust automation systems. #### **Key Takeaways:** 1. REST API simplifies the integration of network devices with modern automation tools. 2. It’s lightweight, flexible, and easy to use with tools like curl and Python. 3. Real-world applications include configuration management, automated monitoring, and integration with platforms like Ansible and Grafana.

Shopping cart

Subtotal:

Examination Introduction

Learning Method

Study Plan

Exam Center