Course Overview

Managing Industrial Networks for Manufacturing with Cisco Technologies (IMINS2024) is a lab-intensive course, which helps you with the skills required to successfully implement and troubleshoot the most common industry standard protocols while leveraging best practices needed in security and Wireless technologies for today’s industrial networks. The IMINS2024 course helps plant administrators, control system engineers and traditional network engineers in the manufacturing, process control, and oil and gas industries, who will be involved with the convergence of IT and Industrial networks.

This course is job-role specific and enables you to achieve competency and skills to configure, maintain, and troubleshoot industry-standard network protocols as well as wireless and security technologies to ensure that current infrastructures are maximized while developing a converged platform for flexibility to support future business outcomes. Students will be exposed to multiple industrial network technologies as well as products from Cisco and other industrial suppliers.

Virtual Learning

This interactive training can be taken from any location, your office or home and is delivered by a trainer. This training does not have any delegates in the class with the instructor, since all delegates are virtually connected. Virtual delegates do not travel to this course, Global Knowledge will send you all the information needed before the start of the course and you can test the logins.

Course Objectives

Upon completing this course, the learner will be able to meet these overall objectives:

• Upon completing this course, you will be able to meet these objectives:
• Understand the functions of the OSI Layers and TCP/IP Model
• Recognize the differences between Enterprise and Industrial Networks
• Troubleshoot common issues found in Layers 1, 2, 3 of the OSI Model
• Describe the functions and components of Ethernet/IP Protocols
• Configure and troubleshoot CIP on Cisco
• Describe the functions and components of the PROFINET protocol
• Configure PROFINET Protocols on Cisco Industrial Ethernet Devices
• Troubleshoot common PROFINET Issues
• Identify common network threats and resolutions and configure basic security components (Access Lists and AAA Features)
• Configure a wireless network within an industrial environment

Course Content

Module 1: Industrial Networking Concepts and Components

• Contrasting Enterprise and Industrial Environments
• Configuration Tools for Industrial Ethernet Switches
• Exploring Layer 2 Considerations
• Layer 2 Resiliency Using Spanning-tree Protocol
• Layer 2 Resiliency Considerations
• Layer 2 Multicast Control and QoS
• Exploring Layer 3 Considerations

Module 2: General Troubleshooting Issues

• Troubleshooting Methodologies
• Troubleshooting Layer 1
• Troubleshooting Layer 2 Issues
• Troubleshooting Layer 3 Issues

Module 3: Ethernet/IP

• Exploring Ethernet/IP Communications
• Exploring Hardware Capabilities
• Exploring CIP Sync, CIP Motion, and CIP Safety
• Exploring Embedded Switch Technology

Module 4: Troubleshooting EtherNet/IP

• Identifying Common EtherNet/IP Issues
• EtherNet/IP Troubleshooting Methods and Tools

Module 5: PROFINET

• Describe PROFINET Functionality and Connection Method
• Describing Basic PROFINET Devices

Module 6: Configuring PROFINET

• Enabling and Prioritizing PROFINET at L2
• Integrating Cisco Industrial Ethernet Switches

Module 7: Troubleshooting PROFINET

• Identifying PROFINET Troubleshooting Methods
• Exploring PROFINET Troubleshooting Tools

Module 8: Exploring Security Concerns

• Overview Of Defense-in-Depth Strategy
• Controlling Access and Network Traffic

Module 9: 802.11 Industrial Ethernet Wireless Networking

• Understanding 802.11 Networks
• Industrial WLAN Design Considerations

Lab Outline:

Labs are designed to assure learners a whole practical experience, through the following practical activities:

• Connecting to the remote Lab environment
• Configuring 802.1q Trunks
• Configuring and Applying Custom Smartports Macros
• Configuring and Applying EtherChannel
• Configuring Resilient Ethernet Protocol
• Configuring Resilient Ethernet Protocol Features
• Configuring & Verifying Storm Control
• Verify IP IGMP Snooping
• Configure QoS settings
• Using IOS Troubleshooting Tools
• Troubleshooting Layer 2 Endpoint Device Connectivity
• Troubleshooting Layer 2 Inter-Switch Connectivity
• Troubleshooting Broken REP Segment
• Troubleshooting Layer 3
• Perform a Packet Capture
• Troubleshoot Network Issues
• Configure CIP on Industrial Switches
• Troubleshooting EtherNet/IP Communication Issues
• Configuring PROFINET Support
• Troubleshoot PROFINET Communication Issues
• Configure Port Security Mechanisms
• Configure AAA Authentication using Cisco ISE and 802.1x

Course Overview

Version control refers to the tracking and traceability of changes. It is, in a way, akin to the use of a bookmark in a book, added by a reader, to mark the point to return to when they resume reading. In version control, a metaphorical bookmark marks a reference to a snapshot of the code base. Git is a version control tool. Using Git, you can make, track, retrieve, and share changes on a repository. GitHub is a hosting service on which a repository resides.

This is a two-day course that will provide you a thorough understanding of what version control is, why it’s necessary, and how it lends itself to application development and version management. With thorough explanations and interesting activities, you will learn all about using using Git and GitHub optimally.

As you progress, you’ll find helpful tips and tricks, as well as useful self-assessment material, exercises, and activities to help you benchmark your progress and reinforce what you’ve learned. The activities have been devised to simulate real-world conditions in order to equip you with the necessary skills to accelerate software deployment while still retaining security, portability, and affordability. By the end of the course, you will have the right skills to safeguard your application and ensure its speedy developme

Course Objectives

If you are interested in gaining a good grasp of version control in a systematic and practical way by working through real-world scenarios, then this course is for you.

This course will enable you to:

• Understand and implement version control best practises
• Navigate the GitHub UI
• Understand what the Feature Branch Workflow is and implement its features
• Use forking features, such as submodules and rebasing
• Master commands for debugging and maintaining a repository
• Implement continuous integration with CircleCi or TravisCi
• Gain insight into release management and how GitHub enables software releases

Course Content

Lesson 1 – Introduction to Version Control

• Defining Version Control
• Navigating GitHub

Lesson 2 – Versioning Commits

• Introduction to Versioning Commits

Lesson 3 – Fetching and Delivering Code

• Fetching the Code

Lesson 4 – Branches

• Utilizing Workflows

Lesson 5 – Collaborative GIT 

• Forking the Workflow
• Debugging and Maintenance
• Housekeeping

Lesson 6 – Automated Testing and Release Management

• Test Automation
• Automated Pull Requests

Course Overview

Spring Boot 2 is the latest incarnation of the Spring Framework, which is a mature, enterprise-grade, and open source application development framework that provides a flexible and modern alternative to the official Java EE standard. It also provides inversion of control containers for the Java platform.

This is a 3-day course, which balances theory and hands-on applications that are focused on practical takeaways. The course will take you through the fundamentals of the Spring Framework. You will then gain an understanding of how to retrieve data using a relational database. Gradually, you will learn how to create browser-based applications. Lastly, you will grasp the concept of RESTful web-services, APIs, and learn how to implement Spring Security.

Course Objectives

This course complies with instructional design principles for all nine lessons. This will ensure that you repeat and reinforce the knowledge gained at every step. Each and every minute spent on this 3-day course will incrementally take you to the next level.

The course will provide you with knowledge of the following:

• Create a Spring Boot application from scratch
• Write comprehensive tests
• Store data in a relational DB
• Create a RESTful API
• Create a rich web interface
• Secure your application with Spring security

Course Content

Lesson 1 – The Spring Project and Framework

• The Spring Project and Framework
• Bootstrapping
• The Application Context
• Additional Tools- Project Lombok

Lesson 2 – Building a Spring Application

• Dependency Injection in Spring
• Configuration of Spring Boot Applications

Lesson 3 – Testing Spring Applications

• Applying Unit Tests
• Integration Tests

Lesson 4 – The MVC Pattern

• Introducing the MVC pattern
• Spring Web MVC Basics
• Spring Web MVC Controller

Lesson 5 – Displaying Information Using Web Pages

• HTML Templating with Thymeleaf
• Displaying Data Using a Model and Data Binding

Lesson 6 – Passing Data Between the View and the Controller

• Form Handling
• Form Input Types and Value Binding

Lesson 7 – RESTful APIs

• What is a RESTful API?
• REST controllers in Spring
• Hypermedia with Spring Boot

Lesson 8 – Web Application Security

• Securing your Web Application
• Spring Security

Lesson 9 – Persisting Data Using a Database

• Relational Databases and SQL
• Access the Database from Java with JDBC and JdbcTemplate
• Schema Updates
• Outlook – Advanced Database Support

Course Overview

With the help of this course, you can equip yourself with the skills required to create modern, progressive web applications that load quickly and efficiently. This fast-paced course is a great way to learn how to build an effective UX by using the new features of Angular 7 beta, without wasting your efforts on searching for referrals.

To start off, you’ll install the Angular CLI and set up a working environment, followed by learning how to distinguish between the container and presentational components. You’ll explore advanced concepts such as making requests to a REST API from an Angular application, creating a web server using Node.js and Express, and adding dynamic metadata. Toward the end of this course, you’ll gain an understanding of how to implement and configure a service worker using Angular PWA and how to deploy a server-side rendered app to the cloud.

By the end of this course, you’ll have developed the skills needed to serve your users views that load instantly, while reaping all the SEO benefits of improved page indexing.

Course Objectives

After completing this course, you will be able to:

• Identify what makes an Angular application SEO-friendly
• Generate commands to create components and services
• Distinguish between the container and presentational components
• Implement server-side rendering using Angular Universal
• Create a web server using Node.js and Express
• Add dynamic metadata to your web application
• Deploy a server-side rendered app to the cloud
• Implement and configure a service worker using Angular PWA

Course Content

Lesson 1: Creating the Base Application

• Installing Angular CLI
• Creating a New Application
• Configuring Global Styles
• Creating the UI for the Application
• Creating the App Logic

Lesson 2: Server-Side Rendering

• Generating the Universal Code
• Enabling Support for Lazy Loading
• Building the Server
• Adding Dynamic Metadata
• Deploying to Production

Lesson 3: Service Workers

• Installing Angular PWA
• Configuring the Service Worker
• Testing the Service Worker
• Debugging the Service Worker

Course Overview

Automated testing is the way forward. It is faster than manual testing, and you can easily rerun your tests at no extra cost. With this course, you’ll learn how to use Selenium to efficiently test your own applications.

There are several challenges when writing automated tests for web applications: selecting an adequate test framework, using appropriate selectors to avoid flaky tests, and building a good testing framework. This course walks you through these challenges and provides you with the knowledge to overcome hurdles in testing by developing stable and effective testing solutions. You will learn the complete process of automated testing, such as configuring your environment, creating and running automated tests, analyzing reports, and troubleshooting errors by using a Selenium Grid.

Course Objectives

This course starts with the fundamentals and in an incremental fashion provides you with the skills you need to run automated tests on your own web application.

We’ll begin this course by understanding the importance of automating tests. Then, we will learn how to choose good selectors for navigating through your web application while highlighting best practices and techniques.

After writing your first tests, you will go through the object model to help create your own advanced test cases. You will learn how to analyze a test report, track timing errors, and separate real issues from “flaky” tests. You will also learn how to configure and connect to a local grid, a network grid, and a third-party service. By the end of the course, you will have the skills you need to run automated tests on your own web application.

After completing this course, you will be able to:

• Get an overview of Selenium
• Identify what to automate in a project and configure the environment
• Learn to control browser behaviour and manipulate web page elements
• Understand the nuances of writing tests and creating test suites
• Create UI tests with Selenium WebDriver and analyze test results
• Troubleshoot errors in automation and build out meaningful reporting

Course Content

Lesson 1: Getting Started

• What is Automation?
• Selenium Overview
• Environment Configuration

Lesson 2: WebDriver Functionality

• Overview of Frequently Used Methods
• Instantiating WebDriver
• Controlling the Browser Window

Lesson 3: WebElement Functionality

• Using Browser Developer Tools
• Overview of WebElement Functionality
• Interacting with Elements on a Page
• Element Locator Types

Lesson 4: Advanced Element Location

• Going through the DOM
• Searching within Previously Found Elements
• Creating Complex Locators when an Element is Not Easily Reachable

Lesson 5: Waiting for Elements

• Implicit Waits
• Explicit waits
• Implicit Versus Explicit Waits
• Waiting for an Element with a Custom Written Condition

Lesson 6: Page Object Model

• Introduction to the Page Object Model
• Modeling a Web Application Using Page Objects
• Creating a Selenium Framework for a Web Application

Lesson 7: Writing Tests

• What is a Test Framework?
• Choosing a Test Framework
• Creating Test Scripts and Suites
• Validating and Viewing Results

Lesson 8: Analysis and Troubleshooting

• Analyzing the Test Report
• Tracking Down Timing Errors
• Separating Real Issues from “Flaky” Tests

Lesson 9: Using a Selenium Grid

• Configuring and Connecting to a Local Grid
• Configuring and Connecting to a Network Grid
• Connecting to a Third-Party Service

Course Overview

Data analysis is crucial to accurately predict the performance of an application. The course begins by getting you started with R, including basic programming and data import, data visualization, pivoting, merging, aggregating, and joins. Once you are comfortable with the basics, you will read ahead and learn all about data visualization and graphics. You will learn data management techniques such as pivots, aggregations, and dealing with missing values. With this various case studies and examples, this course gives you the knowledge to confidently start your career in the field of data science.

This is a hands-on guide that walks you through concepts with examples using built-in R data. Every topic is enriched with a supporting example that highlights the concept, followed by activities that will gradually build into a full data science project to showcase skills learned. You will perform an end-to-end analysis, starting a data science portfolio.

Course Objectives

The course begins by getting you started with R, including basic programming and data import, data visualization, pivoting, merging, aggregating, and joins. You will learn how to:

• Use the basic programming concepts of R such as loading packages, arithmetic functions, data structures, and flow control
• Import data to R from various formats, such as CSV, Excel, and SQL
• Clean data by handling missing values and standardizing fields
• Perform univariate and bivariate analysis using ggplot2
• Create statistical summary and advanced plots, such as histograms, scatter plots, box plots, and interaction plots
• Apply data management techniques, such as factors, pivots, aggregation, merging, and dealing with missing values, on the example data sets

Course Content

Lesson 1: INTRODUCTION TO R

• Using R, RStudio, and Installing Useful Packages
• Variable Types and Data Structures
• Basic Flow Control
• Data Import and Export
• Getting Help with R

Lesson 2: DATA VISUALIZATION AND GRAPHICS

• Creating Base Plots
• ggplot2
• Interactive Plots

Lesson 3: DATA MANAGEMENT

• Factor Variables
• Summarizing data
• Splitting, Combining, Merging, and Joining Datasets

Course Overview

Equip yourself with writing efficient and powerful code which can be easily managed. This fast-paced guide to Scala leads you through the functional and object-oriented concepts that are used in Scala.

You’ll learn how to write safer and stable code by using pure functions and immutable data structures.

Scala is a general-purpose programming language, combining elements of object-oriented with functional programming. It is backed by a strong type system and is designed to be concise.

Course Objectives

• Write Scala applications
• Effectively participate in existing Scala projects
• Recognize and use typical idioms and patterns
• Identify the principles of functional programming and know the essence of advanced functional patterns

Course Content

Day One – Getting Started with Scala
 
We begin our day by easing ourselves into the world of Scala. We setup our development environment and learn some basics of Scala language.

Lesson One – Setting up the Development Environment

Before starting with the Scala language itself, we will identify how to setup our development environment. we will learn the basics of Scala, such as what the simple Scala program looks like and what a typical developer flow is. We will identify how to structure the Scala program. We will also cover some aspects of testing your Scala program by using Unit testing.

• Recognize the structure of a Scala project
• Identify the use of Scala’s sbt tool (interactive build tool) for building and running your project
• Identify how to use the IDE
• Implement interactions with a simple chatbot

Lesson Two – Basic Language Features

We will explore the so-called ‘OO’ part of Scala such as Java or C++. The object-oriented part of Scala will cover classes and objects, traits, pattern matching, case class, and so on. Finally, we will implement the object-oriented concepts that we learn to our chatbot application.

• Identify the structure of non-trivial Scala programs
• Identify how to use main object-oriented facilities: objects, classes, and traits
• Recognize the details of function call syntax and parameter-passing modes

Lesson Three – Functions

We will cover functional programming with Scala and how object-oriented and functional approaches complete each other. We will cover generic classes and also cover how to create user-defined pattern matching and why is it useful.

• Identify the basics of functional programming
• Identify the basics of generic types in Scala
• Implement user-defined pattern matching
• Recognize and use functional compositional patterns
• Day Two – Scala Collections and Type System
• We begin our day by learning various scala collections and then we will cover types.

Lesson One – Scala Collections

We will start by learning how to work with lists. Afterwards, we’ll generalize to sequences and cover some more relevant data structures. Finally, we’ll look at how collections relate to monads and how we can use that knowledge to make some powerful abstractions in our code.

• Identify the Scala collections available in the standard library
• Identify how to abstract on sequences by using higher-order Functions
• Implement the important design principles for working with Scala collections

Lesson Two – Scala Type System

In this lesson, we will cover the type system and polymorphism. We will also cover the different types of variance, which provides a way to constrain parameterized types. Finally, we will cover some advanced types such as abstract type members, option, and so on.

• Identify the Scala type hierarchy
• Use the features the Scala type system provides
• Identify abstractions that the Scala type system enables

Lesson Three – Implicits

We will cover implicit parameters and implicit conversions. We’ll be learning about how they work, how to use them, and what kind of benefits and perils they provide.

• Describe implicits and how the Scala compiler handles them
• Explain the design patterns that implicits enable
• Analyze the common issues that may arise by overusing implicits

Day Three – Building Code using Functional Programming

We begin our day by focusing on the functional programming aspects of Scala. We will then cover Cats and Doobie, which are the two popular functional programming libraries.

Lesson One – Functional Idioms

We’ll cover the core concepts of functional programming like Pure functions, immutability, and higher-order functions. We’ll introduce some of the design patterns that are prevalent in large functional programs. Finally, we’ll cover two popular functional programming libraries called Cats and Doobie, and use them to write some interesting programs.

• Identify the core concepts of functional programming
• Recognize and implement the popular functional programming design patterns
• Implement Cats and Doobie in your own Scala projects

Lesson Two – Domain Specific Languages

We will cover how Scala makes it possible to write powerful DSLs by providing a few interesting language features. We’ll have a brief look at what DSLs are in general terms. We’ll also cover a DSL that you’ll very likely be using if you’re going to work with Scala professionally. Finally, we will implement our own DSL.

• Identify the use of Domain Specific Languages (DSLs)
• Use the DSL that ScalaTest, a popular testing library for Scala, provides
• Design your own DSLs in Scala

Course Overview

Node.js is considered a game changer. It is the biggest shift of the decade in web development. Node.js applications are written in JavaScript, which enables scenarios such as single-language application stacks and the sharing of code between the server and the client.

The goal of this course is to guide you through the emerging world of patterns, techniques, and practices, helping you to understand proven solutions to common problems.

Throughout the course, you will be presented with several libraries and technologies. They will be used to demonstrate a pattern or technique, and will also give you great exposure to the Node.js ecosystem and its set of solutions.

Course Objectives

This course will uncover a set of patterns to solve common problems encountered in Node.js design and coding. Finally, you will explore writing modular and efficient Node.js applications.

Course Content

Lesson 1: Welcome to the Node.js Platform

• The Node.js Philosophy
• Introduction to Node.js 6 and ES2015
• The Reactor Pattern

Lesson 2: Node.js Essential Patterns

• The Callback Pattern
• The Module System and its Pattern
• The Observer Pattern

Lesson 3: Asynchronous Control Flow Patterns with Callbacks

• The Difficulties of Asynchronous Programming
• Using Plain JavaScript
• The async Library

Lesson 4: Asynchronous Control Flow Patterns with ES2015 and Beyond

• Promise
• Generators
• Async/Await Using Babel
• Comparison

Lesson 5: Coding with Streams

• Discovering the Importance of Streams
• Getting Started with Streams
• Asynchronous Control Flow with Streams
• Piping Patterns

Lesson 6: Design Patterns

• Factory
• Revealing Constructor
• Proxy
• Decorator
• Adapter
• Strategy
• State
• Template
• Middleware
• Command

Lesson 7: Wiring Modules

• Modules and Dependencies
• Patterns for Wiring Modules
• Wiring Plugins

Lesson 8: Universal JavaScript for Web Applications

• Sharing Code with the Browser
• Introducing Webpack
• Fundamentals of Cross-Platform Development

Course Overview

This is a 3-day course which balances theory and hand-on applications that are focused on practical takeaways to learn Azure SQL Database.

This course complies with instructional designing principles for all the 9 lessons. This will ensure that you repeat and reinforce your gained knowledge at every step. Each and every minute spent during this 3-day course will incrementally take you to a next level.

Course Objectives

If you are interested in developing new or migrating existing applications with Azure SQL Database, then this course is for you.
 
The course will provide enough knowledge of the following:

• Provision a new Azure SQL Database or Migrate an existing on-premise SQL Server database to Azure SQL Database
• Backup and restore Azure SQL Database
• Secure and scale an Azure SQL Database
• Monitor and tune an Azure SQL Database
• Implement high availability and disaster recovery with Azure SQL Database
• Automate common management tasks with PowerShell
• Develop a scalable cloud solution with SQL Database

Course Content

Microsoft Azure SQL Database Primer

• Azure SQL Database Architecture

Migrating an SQL Server Database to an Azure SQL Database

• Azure SQL Database Service Tiers
• Determining an Appropriate Service Tier
• Determining Compatibility Issues
• Determining the Migration Method

Backing up the SQL Database

• Automatic Backups
• Manual Backups

Restoring an Azure SQL Database

• Restore Types

Securing an Azure SQL Database

• Access Control
• Proactive Security
• Scaling Out Azure SQL Database
• Vertical Scaling
• Horizontal Scaling

Elastic Pools

• Introducing Elastic Pools
• Elastic Jobs

High Availability and Disaster Recovery

• High Availability
• Disaster Recovery

Monitoring and Tuning Azure SQL Database

• Monitoring an Azure SQL Database Using the Azure Portal
• Tuning an Azure SQL Database

Course Overview

This is a 2-day course packed with the right balance of theory and hands-on activities to help you take your TypeScript skills to the next level.

This course complies with instructional designing principles for all the 4 lessons. This will ensure that you frequently repeat and reinforce the knowledge you gain. Having been designed for the development of large applications, TypeScript is being widely incorporated into popular projects such as Angular.

TypeScript is the future of JavaScript. TypeScript offers a sliding scale of how much or how little effort you want to put into your declarations: the more effort you put in, the more type safety and code intelligence you get. TypeScript allows developers to write readable and maintainable web applications. Adopting TypeScript results in more robust software, while still being deployable in apps where regular JavaScript is running.

Pure JavaScript lacks certain language features that are taken for granted in languages such as C# and Java. For example, it has no built-in module system, meaning that there’s no standard way of producing self-contained blocks of code that present well-defined interfaces to developers.

Course Objectives

In this course, we will begin by learning the fundamentals of TypeScript and eventually move toward advanced concepts. Learn how TypeScript relates to JavaScript that you may have written before. We will understand the benefits of TypeScript and how it can help you avoid software defects. We will learn to use type guards, check null and undefined, create tagged union types, and compare the performance of algorithms.

We will use TypeScript to build a weather forecast widget with Angular. We will then progress by building a note-taking client/server application using Angular, Node.js, and MongoDB. Finally, we will create a real-time chat application with React.

By completing this course, you will be able to build interesting TypeScript projects. This course will take your current TypeScript knowledge to the next level.

Here are the important topics that this course will cover:

• Learn the fundamentals of TypeScript
• Build a weather forecast widget with Angular
• Create building a note-taking client/server application using Angular, Node.js, and MongoDB
• Create a real-time chat application with React

Course Content

Lesson 1: TypeScript Fundamentals

• Introduction to TypeScript
• Type Checking
• Advanced Type Analysis Features
• Comparing Performance of Algorithms

Lesson 2: Building a Weather Forecast Widget with Angular 4

• Using Modules
• Creating the First Component
• Using the Component in Other Components
• Using the Main Component

Lesson 3: Note-Taking Client/Server App

• Setting up the Server
• Integrating with MongoDB
• Creating the Client Side with Angular

Lesson 4: Real-Time Chat

• Setting up the Project
• Writing the Server
• Creating the Chat Room