Affiche CBT Nuggets Windows PowerShell v2-v3-v4 Ultimate
  • 1 saisons
  • 90 épisodes
  • Début :
    0000
  • Statut :
    En Cours
  • Hashtag :
    #

Finally, it’s the Windows PowerShell class you’ve always wanted — Covering every version of PowerShell, this course by Don Jones clearly explains the differences between each version currently used in production environments and covers literally EVERYTHING an administrator might want to do with the shell. Start from absolute zero, and learn to use the shell as it was meant to be used. Advance into scripting and “toolmaking,” learning to make command-line and graphical tools from scratch. Move into advanced, real-world, field-proven topics such as reporting, trend analysis, and more. Learn super-advanced features like workflow and Desired State Configuration. You’ll even find topics that go beyond the shell, such as using Component Object Model and .NET Framework classes in the shell. It’s one course, with EVERYTHING the shell touches. Encompassing more than 30 HOURS of instruction, combined with self-paced hands-on labs (and video lab reviews), this is the ultimate class for learning Windows PowerShell.

0
0
0
0

Saisons & épisodes Les résumés de tous les épisodes de CBT Nuggets Windows PowerShell v2-v3-v4 Ultimate

S01E01 Course Introduction and Lab Setup 00/00/0000 Don't skip this Nugget! It outlines the strategy for the entire course, including how Don deals with the many different versions of PowerShell. You'll also learn how Don's lab environment is configured, and learn what you might want to have on hand to create your own lab/playground.
S01E02 Windows PowerShell Orientation and Requirements 00/00/0000 Get to know Windows PowerShell — every version! You'll explore the console and ISE environments and learn about system requirements
S01E03 Finding and Discovering Commands 00/00/0000 Here's the most important Nugget in the course: how to get PowerShell to tell you what it can do, and how the shell teaches you how to use the shell.
S01E04 Interpreting Command Help 00/00/0000 PowerShell includes an extensive help system, but if you don't know how to use it, it might was well not exist. Conquer the shell by learning to read the "Friendly Manual," complete with a mental decoder ring for command syntax help.
S01E05 Running Commands 00/00/0000 Learn the correct syntax for running PowerShell commands including the most common "gotchas" that trip up newcomers.
S01E06 Working with PSProviders and PSDrives 00/00/0000 Not everything in PowerShell is managed by commands. Sometimes, you'll rely on PSDrives to perform management tasks. They're not as cleanly documented, so you'll want to pay close attention in this Nugget.
S01E07 Variables, Strings, Hashtables, and Core Operators 00/00/0000 A big Nugget of seemingly miscellaneous information that's all actually very important. The variety of topics covered here will help prepare you for what's ahead. This Nugget touches on variables, string values, hashtables (you'll learn to love 'em), core comparison operators, and a lot more.
S01E08 Regular Expression Basics 00/00/0000 Although this isn't a tutorial on regex syntax, it will show you some of the basics. More importantly, you'll learn some of the many ways PowerShell uses regular expressions, including some that very few people know about!
S01E09 Running External Commands: Tips and Tricks 00/00/0000 One of the toughest things in PowerShell is running picky external commands. Normally, the shell does fine with these, but when it doesn't, oh, boy! But you'll learn the tips and tricks for making it easy, probably saving you countless hours!
S01E10 Learning the Pipeline: Exporting and Converting Data 00/00/0000 Let's start using what makes PowerShell unique: its object-oriented pipeline. Your exploration starts with basic exporting and conversion tasks, a key way to get data out of the shell into various formats.
S01E11 Understanding Objects in PowerShell 00/00/0000 PowerShell's pipeline, unlike Unix shells, isn't text-oriented. Mastering objects is the key to mastering the shell and getting the most from it.
S01E12 Core Commands: Selecting, Sorting, Measuring, and More 00/00/0000 Now that you're comfy with objects, let's start using them to manipulate data in the pipeline, producing exactly the output you want.
S01E13 How the PowerShell Pipeline Works 00/00/0000 Let's step back a bit and look under the hood at PowerShell's pipeline, how it works, and how you can make it work better for you.
S01E14 Formatting Command Output 00/00/0000
S01E15 Comparison Operators and Filtering 00/00/0000 What do you do when the pipeline contains things you don't want? Filter 'em out! In this Nugget, you'll learn exactly how to do that!
S01E16 Advanced Operators 00/00/0000 Let's explore some of PowerShell's more advanced comparison, math, and other operators — all useful tools in getting exactly what you want from the shell.
S01E17 Setting Default Values for Command Parameters 00/00/0000 Tired of typing the same parameters and values over and over? Learn how to set default values, either globally in the shell or from within a specific script.
S01E18 Enumerating Objects in the Pipeline 00/00/0000 You've learned how to use methods to make objects do things, and this Nugget takes you one step further by showing you how to "enumerate" objects, so that you can have a bunch of them all do something at once.
S01E19 Soup to Nuts: Completing a New Task 00/00/0000 Let's start from scratch, take everything you've learned so far, and complete a brand-new task. This will really illustrate the way to use PowerShell to discover, learn, and execute unfamiliar tasks, complete with the occasional hiccup and back-track — just like in the real world.
S01E20 LAB A: PowerShell Core Review 00/00/0000 Download and complete the lab document before reviewing this Nugget, which covers sample solutions to the lab problems.
S01E21 PowerShell Remoting Basics 00/00/0000 It's time to dive into Remoting, one of PowerShell's most exciting and useful features. In this Nugget, you'll learn about Remoting's architecture, basic operation, and biggest gotchas
S01E22 Persistent Remoting: PSSessions 00/00/0000 Continuing with Remoting, you'll now learn how to create and use persistent sessions, a valuable technique that you'll build upon going forward.
S01E23 Implicit Remoting: Using Commands on Another Computer 00/00/0000 Using sessions to copy commands from a remote computer to your own lets you consume commands directly from a server, rather than having to laboriously install everything on your workstation.
S01E24 Advanced Remoting: Passing Data and Working with Output 00/00/0000 Getting data to remote computers and working with the output of remote commands can be tricky. It's fraught with gotchas, but we'll clear them all up right here.
S01E25 Advanced Remoting: Crossing Domain Boundaries 00/00/0000 Let's go hardcore and look at the REAL WORLD, REAL WAY to communicate across domains or with non-domain computers. No shortcuts, no lab tricks — this is 100 percent real!
S01E26 Advanced Remoting: Custom Session Configurations 00/00/0000 Set up delegated administration by creating custom, constrained PowerShell endpoints that other users can connect to in order to run specified commands.
S01E27 Web Remoting: PowerShell Web Access 00/00/0000 One last Remoting topic: How to set up an HTML Web-based PowerShell gateway using Windows Server 2012 (and later) PowerShell Web Access (use it to manage ANY client or server version!)
S01E28 LAB B: PowerShell Remoting Review 00/00/0000 Spend some time working on the lab document before reviewing the sample solutions in this Nugget.
S01E29 WMI and CIM: WMI, Docs, and the Repository 00/00/0000 Windows Management Instrumentation and Common Information Model are two PowerShell-friendly technologies for working with management data. Learn their architecture, how to explore them, and how to avoid maximum frustration when working with them.
S01E30 WMI and CIM: Using WMI to Commands Query Data 00/00/0000 Continue your WMI/CIM education with the old-school WMI commands in Windows PowerShell.
S01E31 WMI and CIM: Using CIM Commands to Query Data 00/00/0000 Upgrade your WMI/CIM education to the new (v3+) CIM commands, which are Microsoft's standards-based "way forward" for working with the repository.
S01E32 WMI and CIM: Filtering and WMI Query Language 00/00/0000 Continue your WMI/CIM education by learning the native filtering language and the WMI Query Language (WQL).
S01E33 WMI and CIM: Associations 00/00/0000 The trickiest WMI/CIM task: associations and associator classes. Conquer them and go where few WMI experts have ever gone!
S01E34 WMI and CIM: Working with CIM Sessions 00/00/0000 Learn how to use persistent CIM sessions to communicate with both up-level and down-level computers, for all-in-one management, using both old and new techniques.
S01E35 WMI and CIM: Executing Instance Methods 00/00/0000 Learn to use WMI and CIM instance methods to effect change and make things happen, on both local and remote computers.
S01E36 LAB C: WMI and CIM Review 00/00/0000 Spend some time working through this hands-on lab, and then review this Nugget to see sample solutions.
S01E37 Background Job Basics: Local, WMI, and Remoting Jobs 00/00/0000 Let's move on to PowerShell's job system, which enables you to have multiple tasks running in parallel in the background! Here, you'll learn about some core job types, including local jobs, WMI jobs, and Remoting jobs.
S01E38 Scheduled Background Jobs 00/00/0000 Another job type in PowerShell, introduced in v3, is the "scheduled job." Slightly different from and related to scheduled TASKS, these jobs offer flexibility and the ability to run when PowerShell isn't even open.
S01E39 LAB D: Jobs Review 00/00/0000 Take some time to complete these hands-on lab exercises before reviewing this Nugget for sample solutions.
S01E40 PowerShell Script Security 00/00/0000 We're starting to move into the world of PowerShell scripting, and the first thing we'll need to cover is security. This short Nugget will explain key concepts and help you make some important decisions for your environment.
S01E41 Prompting for Input, Producing Output 00/00/0000 There's a right way and a wrong way to work with user input and output in the shell. Learn 'em all in this Nugget!
S01E42 Creating Basic Parameterized Scripts 00/00/0000 Moving from the command-line to a formal script isn't complicated, and you can pick up some great functionality for very little extra effort.
S01E43 PowerShell Scripting: Logical Constructs 00/00/0000 As we move into actual scripting, we'll start with a foundation in the major scripting constructs that make logical decisions.
S01E44 PowerShell Scripting: Looping Constructs 00/00/0000 Continuing with scripting, we'll now look at constructs that enable repetition and looping.
S01E45 PowerShell Scripting: Basic Functions, Filters, and Pipeline Functions 00/00/0000 Scripting is often built around modular units of work, so we'll look at those basic units in this nugget. You'll build on these going forward.
S01E46 PowerShell Scripting: Best Practices 00/00/0000 Before we get further into scripting, let's stop and look at best practices. These are designed to make your scripts easier to read and maintain, as well as helping to prevent common bugs.
S01E47 PowerShell Scripting: From Command to Script to Function to Module 00/00/0000 Let's take a complete scripting task. We'll start with a command and then evolve that into a standalone, easily distributed script module that features a number of very cool bits of functionality.
S01E48 PowerShell Scripting: Scope 00/00/0000 You've seen scope before (in the Nugget on setting parameter defaults), but it's time to formally explore this important concept, and talk about some do's and don'ts.
S01E49 PowerShell Scripting: Combining Data from Multiple Sources 00/00/0000 So far, your scripting education has focused on parameterizing individual commands. We'll now advance into multiple commands, where we'll combine their output into a single, unified output object that complies with PowerShell standards.
S01E50 LAB E: PowerShell Scripting Review 00/00/0000 Take some time to try and complete this lab before reviewing the sample solution in this Nugget.
S01E51 Advanced Functions: Adding Help 00/00/0000 Most folks agree that adding documentation to your scripts is a good idea - but why not do so in a way that makes your comments useful for someone RUNNING the script, too?
S01E52 Advanced Functions: Parameter Attributes 00/00/0000 We'll explore all of the various attributes you can add to function parameters, getting the shell to do more work for you when it comes to validation, prompting, defaults, and more.
S01E53 Advanced Functions: Pipeline Input 00/00/0000 Add the ability to accept pipeline input to your functions, making them work more like real cmdlets.
S01E54 Advanced Functions: Parameter Sets 00/00/0000 Learn to build functions that, just like real cmdlets, offer multiple different parameter sets, and learn how to work with those parameter sets inside your code.
S01E55 LAB F: Advanced Functions Review 00/00/0000 Take some time to try and complete this lab before reviewing the sample solution in this Nugget.
S01E56 Creating Private Utility Functions and Preference Variables 00/00/0000 Extend your modules by adding internal-use-only (private) functions, along with public preference variables.
S01E57 Adding Error Capturing and Handling to a Function 00/00/0000 We'll add basic abilities to detect anticipated errors and deal with them gracefully from within a function.
S01E58 Advanced Error Handling 00/00/0000 Let's dig deeper into error handling and review some of the more advanced options and their differences that you may run across.
S01E59 Error Handling the Old Way: Trap 00/00/0000 You may run into this old way of error handling, and it does have some unique features, so it's worth learning how it works.
S01E60 Debugging Techniques 00/00/0000 Learn to use PowerShell's two main debugging features, as well as a plethora of core techniques for making debugging more of a science and less of a trial-and-error effort.
S01E61 Creating Custom Formatting Views 00/00/0000 Learn to apply customized default formatting to object output, including your own custom objects.
S01E62 Creating Custom Type Extensions 00/00/0000 Learn to dynamically extend objects in PowerShell to include your own script properties, methods, and more.
S01E63 Working with SQL Server (and other) Databases 00/00/0000 Learn to connect directly to SQL Server (and other) databases to read and write data. It's WAY easier than manipulating an Excel spreadsheet from code!
S01E64 Working with XML Data Files 00/00/0000 Working with XML can seem tricky, and may even look a lot like C# coding. But once you know the trick, there are some simple and reusable patterns you can use to do whatever you want.
S01E65 Supporting –WhatIf and –Confirm in Functions 00/00/0000 Commands that modify the system state should support -WhatIf and -Confirm parameters. So let's see how to add that support in the commands you write.
S01E66 Troubleshooting and Tracing the Pipeline 00/00/0000 Take an in-depth look at how the pipeline works, and actually SEE how PowerShell moves objects from one command to the next.
S01E67 Using Object Hierarchies for Complex Output 00/00/0000 What do you do when you need to create output objects whose properties are actually MORE objects? It's called an "object hierarchy," and we'll look at how to make them and work with the output.
S01E68 Creating a Proxy Function 00/00/0000 Proxy functions allow you to start with an existing command, and either remove or add functionality to it, all with minimal coding.
S01E69 LAB G: Advanced Scripting Review 00/00/0000 Take some time to try and complete this lab before reviewing the sample solution in this Nugget.
S01E70 From the Field: Enhanced HTML Reporting 00/00/0000 Here's something practical you can do with PowerShell right away: Use it to build HTML-based inventory reports! These are great-looking, dynamic, and can be incredibly powerful.
S01E71 From the Field: Trend Analysis Reporting 00/00/0000 Here's something practical you can do with PowerShell right away: Pull data from your computers into a SQL Server (even the free Express edition) database, and use that data to generate trend analysis reports.
S01E72 From the Field: Scraping HTML Pages 00/00/0000 Here's something practical you can do with PowerShell right away: Use PowerShell to retrieve Web pages and "scrape" specific content from them using pattern-matching and DOM manipulation.
S01E73 Introduction to PowerShell Workflow 00/00/0000 Introduced in PowerShell v3, Workflow provides a specialized way of executing long-running, recoverable tasks. This introduction will help get you started with this technology.
S01E74 Desired State Configuration: The Basics 00/00/0000 Understand the basics of DSC, including its architecture and core feature set. You'll also see some changes to Don's lab environment that will accommodate DSC.
S01E75 Desired State Configuration: Configuration Scripts and Pull Servers 00/00/0000 Learn everything about writing and deploying configuration scripts. You'll see a configuration script example, and learn how to configure a DSC pull server from scratch.
S01E76 Desired State Configuration: Writing Resources 00/00/0000 Get an overview of writing your own DSC resources, a special kind of PowerShell script module that provides DSC with new capabilities.
S01E77 Controller Scripts: Automating Business Processes 00/00/0000 We've talked a lot about "toolmaking" so far, but what do you do with your tools? Create "controller" scripts. In this Nugget, you'll see how to blend tools together to automate key business processes.
S01E78 Controller Scripts: A Menu of Tools 00/00/0000 Continuing our exploration of "controller" scripts that put tools to use, let's see how to create a text-based menu that provides controlled access to your tools.
S01E79 Creating a GUI Tool: The GUI 00/00/0000 GUIs are a special kind of controller script, and in this Nugget we'll stat by using drag-and-drop tools to build a cool-looking GUI.
S01E80 Creating a GUI Tool: The Code 00/00/0000 Taking our GUI from the previous Nugget, we'll start attaching code to make it functional
S01E81 Creating a GUI Tool: The Output 00/00/0000 Continuing with our GUI from the previous Nugget, we'll create a few different ways of displaying output to end users.
S01E82 Creating a GUI Tool: Using Data Tables 00/00/0000 We'll look at a powerful technique often employed in GUI-based tools: Data Tables.
S01E83 LAB H: Automating a Business Process 00/00/0000 Consider this your final exam: Your lab document offers a business process that needs to be automated. Build the tools, create the controller, and automate the entire process! Take some time to try and complete the lab on your own before viewing this sample solution.
S01E84 Globalizing a Function or Script 00/00/0000 Prep your scripts to "speak different languages" by turning static strings into coded placeholders.
S01E85 Discovering and Using COM Objects 00/00/0000 Discover the good and bad news about using old-style Component Object Model (COM) objects in PowerShell, along with how-to examples.
S01E86 Discovering and Using .NET Classes and Instances 00/00/0000 How to find, use, and understand .NET Framework classes within PowerShell.
S01E87 Using Type Accelerators 00/00/0000 Understand what you're looking at when you see people using [void] and [string] in a script, and learn some cool tricks with [adsi] and [wmi].
S01E88 The Big Gotchas in PowerShell 00/00/0000 Avoid some of the biggest "gotchas" in PowerShell with this concise roundup of the ones that trip up the most people.
S01E89 Fun With Profiles 00/00/0000 Use profiles to set up your PowerShell environment the way you like it, every time. Change prompts, set colors, load modules, and more.
S01E90 Random Tips and Tricks 00/00/0000 Some final random tips and tricks as we wrap up this collection of Nuggets.

Les critiques & échangesDiscussions et débats sur la série