{"id":4677,"date":"2025-05-08T20:23:43","date_gmt":"2025-05-08T20:23:43","guid":{"rendered":"https:\/\/www.examsnap.com\/certification\/?p=4677"},"modified":"2026-09-29T19:32:30","modified_gmt":"2026-09-29T19:32:30","slug":"powershell-guide-for-connecting-to-remote-containers","status":"publish","type":"post","link":"https:\/\/www.examsnap.com\/certification\/powershell-guide-for-connecting-to-remote-containers\/","title":{"rendered":"PowerShell Guide for Connecting to Remote Containers"},"content":{"rendered":"

In modern software development, containers have become an essential tool for creating isolated and reproducible environments. The integration of Docker containers within Visual Studio Code (VS Code) takes this a step further by providing a seamless and powerful development experience. Containers help address several challenges faced by developers, including environment consistency, dependency management, and the complexity of cross-platform development.<\/span><\/p>\n

VS Code\u2019s extensibility allows developers to interact with Docker containers directly from the editor, enhancing productivity and enabling smoother workflows. In this article, we will explore how Docker containers integrate with VS Code and how they can be used for PowerShell development. We will delve into the practical and conceptual benefits of using containers, such as isolation of dependencies, reproducibility of environments, and simplified debugging processes.<\/span><\/p>\n

The Need for Containerized Environments<\/b><\/h3>\n

Developers often face challenges when working with local development environments. Issues such as mismatched software versions, configuration inconsistencies, and incompatible dependencies can lead to frustrating bugs that are difficult to reproduce or resolve. Containers provide a solution by encapsulating everything an application needs to run, including system libraries, environment variables, and runtime dependencies. This ensures that the software behaves the same way in different environments, eliminating the \u201cit works on my machine\u201d problem.<\/span><\/p>\n

By using containers, developers can create isolated environments that mimic production systems closely. This is particularly beneficial when working in teams, as everyone can use the same setup without worrying about system differences. For PowerShell developers, containers offer a way to test and run scripts in controlled environments, making it easier to manage different versions of PowerShell, dependencies, and tools.<\/span><\/p>\n

PowerShell’s Evolution and Its Role in Containerized Development<\/b><\/h3>\n

PowerShell has evolved significantly over the years, transforming from a Windows-only shell into a powerful cross-platform scripting language. The introduction of PowerShell Core brought a major shift, allowing PowerShell to run on Windows, Linux, and macOS. This cross-platform compatibility is crucial for modern development workflows, as it enables developers to write scripts that can run consistently across different operating systems.<\/span><\/p>\n

PowerShell’s flexibility makes it an excellent choice for managing system configurations, automating tasks, and working with cloud services. However, ensuring that PowerShell scripts behave the same way across different systems can be challenging. Containers solve this problem by providing a consistent environment in which PowerShell can be run. Developers can create containers with specific versions of PowerShell, ensuring that scripts work as expected, regardless of the underlying system.<\/span><\/p>\n

Containers also enable developers to test scripts across multiple versions of PowerShell without needing to install each version on their local machine. This is particularly useful for PowerShell developers who need to maintain compatibility with both Windows PowerShell and PowerShell Core. By running multiple containers with different versions of PowerShell, developers can ensure that their scripts function correctly in various environments.<\/span><\/p>\n

Why Use Docker Containers with VS Code?<\/b><\/h3>\n

Integrating Docker containers into development workflows brings several benefits. The most significant advantage is environmental consistency. When using Docker, developers can define their entire development environment in a Dockerfile, which can then be shared with the entire team. This eliminates the need to manually configure each developer’s machine, ensuring that everyone is working with the same environment.<\/span><\/p>\n

Another key benefit is the ability to isolate dependencies. Containers provide a way to run different versions of tools and libraries without interfering with the host system. This is especially important when developing for multiple clients or environments that require different versions of software. With Docker, developers can create containers for each specific environment, ensuring that dependencies do not conflict.<\/span><\/p>\n

Docker containers also enable rapid onboarding of new developers. Instead of spending time setting up local environments and installing dependencies, developers can simply pull a pre-configured container and start coding immediately. This reduces friction for new team members and ensures that everyone is working in a standardized environment.<\/span><\/p>\n

Finally, Docker containers make it easier to develop cross-platform applications. Since containers abstract away the underlying operating system, developers can work in the same environment regardless of whether they are using Windows, macOS, or Linux. This is particularly useful when developing applications that need to run in cloud environments, as developers can create containers that mimic the production environment.<\/span><\/p>\n

Overcoming Local Development Challenges with Containers<\/b><\/h3>\n

Before the widespread adoption of Docker, setting up local development environments often involved installing a variety of tools, SDKs, and libraries. Developers needed to ensure that all software versions matched those in production, which was a time-consuming and error-prone process. Even small discrepancies between local and production environments could introduce bugs or break functionality.<\/span><\/p>\n

For PowerShell developers, maintaining consistency between different versions of PowerShell was a significant challenge. PowerShell Core and Windows PowerShell are different in terms of available cmdlets, modules, and system integrations. This meant that scripts written for one version might not work correctly on another, leading to compatibility issues.<\/span><\/p>\n

Containers provide a solution to these challenges by offering a way to define and reproduce environments consistently. With Docker, developers can create containers with the exact versions of PowerShell and other dependencies needed for their project. This eliminates the need for manual configuration and ensures that the development environment closely mirrors production. Moreover, containers make it easier to reproduce issues that occur in production, allowing developers to debug and test scripts in isolated environments.<\/span><\/p>\n

Isolation of Dependencies and Rapid Environment Setup<\/b><\/h3>\n

One of the main reasons to use Docker containers in development is the isolation of dependencies. Containers allow developers to run different versions of tools, libraries, and SDKs without worrying about conflicts with other projects or the host system. For example, a developer might need to test a PowerShell script against two different versions of the AWS CLI. With Docker, they can create two separate containers\u2014one for each version\u2014and run the script in both environments without interfering with each other.<\/span><\/p>\n

This isolation also speeds up the setup process for new developers. Instead of spending hours configuring a development environment, new team members can pull a pre-configured Docker container and start working immediately. This not only reduces onboarding time but also ensures that everyone is working in the same environment, minimizing the risk of configuration-related issues.<\/span><\/p>\n

Streamlined Debugging and Testing in Containers<\/b><\/h3>\n

Containers provide an ideal environment for testing and debugging code. Developers can spin up containers with all the necessary dependencies and services to simulate production environments. For example, a PowerShell developer might need to test a script that interacts with a database or a cloud service. By using Docker Compose, they can create a multi-container setup that includes the necessary services, such as a database, and test the script in a realistic environment.<\/span><\/p>\n

Visual Studio Code\u2019s Remote Development extensions make it easy to work with Docker containers for testing and debugging. With these extensions, developers can connect to a container, open a terminal, and run commands or scripts as if they were working on a local machine. VS Code\u2019s integrated debugging features allow developers to set breakpoints, inspect variables, and step through code directly inside the container. This makes it easier to identify and fix issues in a controlled environment before deploying the code to production.<\/span><\/p>\n

Cross-Platform Development Made Easy<\/b><\/h3>\n

Cross-platform development has always been a challenge for developers. Applications that work on one operating system might behave differently on another due to differences in system APIs, file path conventions, and other factors. Docker containers help mitigate this issue by providing a consistent environment across different platforms.<\/span><\/p>\n

VS Code, with its support for Docker containers, enables developers to work in the same containerized environment regardless of whether they are using Windows, macOS, or Linux. This is particularly useful when developing applications for cloud environments, where the production systems are typically running Linux. By using Docker containers, developers can develop and test their applications in a Linux-based environment, even if they are working on a Windows or macOS machine.<\/span><\/p>\n

This cross-platform compatibility extends to PowerShell as well. PowerShell Core runs on Windows, Linux, and macOS, but there are differences in how it behaves on each platform. With Docker, developers can create containers that run PowerShell on the specific operating system they need, ensuring that scripts work consistently across all platforms.<\/span><\/p>\n

Docker containers offer a powerful way to solve many of the challenges faced by modern developers, particularly when it comes to maintaining environment consistency, isolating dependencies, and facilitating cross-platform development. By integrating Docker with Visual Studio Code, developers gain access to a flexible, reproducible, and streamlined development environment that makes testing, debugging, and collaboration easier than ever before.<\/span><\/p>\n

Setting Up and Configuring Docker Containers for PowerShell Development in VS Code<\/b><\/h2>\n

In the previous part of this series, we explored the importance of Docker containers in modern software development and the benefits they offer, especially for PowerShell developers. Containers provide a reproducible, isolated environment that can help eliminate common development challenges such as dependency conflicts and environment inconsistencies. In this part, we will take a practical approach to setting up and configuring Docker containers for PowerShell development within Visual Studio Code (VS Code).<\/span><\/p>\n

We will walk through the steps of installing Docker, setting up a Docker container with PowerShell, and configuring VS Code to interact with these containers. By the end of this section, you will be able to work with Docker containers for PowerShell development, testing, and debugging directly within VS Code.<\/span><\/p>\n

Installing Docker and VS Code<\/b><\/h3>\n

Before you can start working with Docker containers, you need to have Docker and Visual Studio Code installed on your system. Additionally, we will use the Remote Development extensions for VS Code to connect to and manage containers.<\/span><\/p>\n

    \n
  1. Installing Docker<\/b>:<\/span>\n
      \n
    • For Linux, you can use your distribution\u2019s package manager (e.g., <\/span>apt<\/span>, <\/span>yum<\/span>, or <\/span>pacman<\/span>) to install Docker.<\/span><\/li>\n
    • On Windows, you can download Docker Desktop from the official Docker website. Docker Desktop is the easiest way to install and manage Docker on Windows, as it includes everything you need to get started.<\/span><\/li>\n
    • Docker relies on the Windows Subsystem for Linux (WSL) on Windows. If you are using Windows, make sure you have WSL2 installed and configured.<\/span><\/li>\n<\/ul>\n<\/li>\n
    • Installing Visual Studio Code<\/b>:<\/span>\n
        \n
      • Visual Studio Code can be downloaded from the official website. It is a lightweight code editor that supports a wide range of languages and development workflows, including Docker-based development.<\/span><\/li>\n<\/ul>\n<\/li>\n
      • Installing the Remote Development Extension<\/b>:<\/span>\n
          \n
        • Once VS Code is installed, open the application and go to the Extensions view (Ctrl+Shift+X).<\/span><\/li>\n
        • Search for \u201cRemote Development\u201d and install the extension pack. This pack includes several useful extensions, including Remote – Containers, which allows you to open and develop inside containers.<\/span><\/li>\n<\/ul>\n<\/li>\n<\/ol>\n

          With Docker and VS Code set up, you are ready to start working with containers.<\/span><\/p>\n

          Pulling a PowerShell Docker Image<\/b><\/h3>\n

          Microsoft offers official PowerShell Docker images that are optimized for use in containers. These images come in different versions based on the operating system and version of PowerShell.<\/span><\/p>\n

          Pulling the Latest PowerShell Docker Image<\/b>:<\/span>
          \n<\/span> Open a terminal and run the following command to pull the latest stable PowerShell image from the Docker Hub:<\/span>
          \n<\/span>
          \n<\/span> docker pull mcr.microsoft.com\/powershell<\/span><\/p>\n

          \u00a0This command will download the latest stable version of PowerShell. If you need a specific version or operating system, you can modify the tag. For example, to install PowerShell on Ubuntu 18.04:<\/span>
          \n<\/span>
          \n<\/span> docker pull mcr.microsoft.com\/powershell:lts-ubuntu-18.04<\/span><\/p>\n

            \n
          1. \u00a0You can check the available tags for the PowerShell image on Docker Hub to select the version and base image that best fit your needs.<\/span><\/li>\n<\/ol>\n

            Running the PowerShell Container<\/b>:<\/span>
            \n<\/span> Once the image is downloaded, you can run a container with PowerShell interactively using the following command:<\/span>
            \n<\/span>
            \n<\/span> docker run -it mcr.microsoft.com\/powershell pwsh<\/span><\/p>\n

            \u00a0This will launch PowerShell inside a new container. You can run any PowerShell command or script within this container. For example:<\/span>
            \n<\/span>
            \n<\/span> Get-Command<\/span><\/p>\n

              \n
            1. \u00a0This will show all available cmdlets within the container.<\/span><\/li>\n<\/ol>\n

              Creating a Dockerfile for Customization<\/b><\/h3>\n

              While the official PowerShell images are a great starting point, you might want to customize the container to include additional tools or configurations. This is where Dockerfiles come in. A Dockerfile is a script that defines how a Docker image is built, including the base image, dependencies, environment settings, and commands to run inside the container.<\/span><\/p>\n

              Let\u2019s create a simple Dockerfile that installs PowerShell on Ubuntu 18.04 and includes additional software for development purposes.<\/span><\/p>\n

              Writing the Dockerfile<\/b>:<\/span>
              \n<\/span> Create a new directory for your project and create a file called <\/span>Dockerfile<\/span> inside it. Add the following contents to the Dockerfile:<\/span>
              \n<\/span>
              \n<\/span> FROM mcr.microsoft.com\/powershell:lts-ubuntu-18.04<\/span><\/p>\n

               <\/p>\n

              # Install additional tools<\/span><\/p>\n

              RUN apt-get update && \\<\/span><\/p>\n

              \u00a0\u00a0\u00a0\u00a0apt-get install -y git curl && \\<\/span><\/p>\n

              \u00a0\u00a0\u00a0\u00a0rm -rf \/var\/lib\/apt\/lists\/*<\/span><\/p>\n

               <\/p>\n

              # Set working directory<\/span><\/p>\n

              WORKDIR \/workspace<\/span><\/p>\n

               <\/p>\n

              # Start PowerShell<\/span><\/p>\n

              ENTRYPOINT [“pwsh”]<\/span><\/p>\n

                \n
              1. \u00a0This Dockerfile starts with the <\/span>mcr.microsoft.com\/powershell:lts-ubuntu-18.04<\/span> image, installs Git and curl, and sets the working directory to <\/span>\/workspace<\/span>.<\/span><\/li>\n<\/ol>\n

                Building the Docker Image<\/b>:<\/span>
                \n<\/span> Once your Dockerfile is written, build the Docker image using the following command:<\/span>
                \n<\/span>
                \n<\/span> Docker build -t custom-powershell.<\/span><\/p>\n

                  \n
                1. \u00a0The <\/span>-t<\/span> flag allows you to name the image (in this case, <\/span>custom-powershell<\/span>), and the<\/span>.<\/span> At the end specifies that the build context is the current directory.<\/span><\/li>\n<\/ol>\n

                  Running the Custom PowerShell Container<\/b>:<\/span>
                  \n<\/span> After the image is built, you can run it interactively:<\/span>
                  \n<\/span>
                  \n<\/span> docker run -it custom-powershell<\/span><\/p>\n

                    \n
                  1. \u00a0This will start the container with PowerShell and the installed tools. You can begin using PowerShell commands and test scripts inside this container.<\/span><\/li>\n<\/ol>\n

                    Configuring VS Code to Use Docker Containers<\/b><\/h3>\n

                    Visual Studio Code has powerful integration with Docker containers, which allows you to develop and test code directly inside containers. To enable this, you need to use the Remote-Containers extension.<\/span><\/p>\n

                      \n
                    1. Opening a Project Inside a Container<\/b>:<\/span>
                      \n<\/span> If you have a project that you want to work on inside the container, you can either clone it from a repository or create a new project. Let\u2019s say you have a project that contains a PowerShell script you want to work on. Create a <\/span>.devcontainer<\/span> directory inside your project\u2019s root folder.<\/span><\/li>\n<\/ol>\n

                      Creating a devcontainer.json File<\/b>:<\/span>
                      \n<\/span> Inside the <\/span>.devcontainer<\/span> directory, create a <\/span>devcontainer.json<\/span> file. This file defines how VS Code will connect to and configure the Docker container. Here\u2019s an example configuration:<\/span>
                      \n<\/span>
                      \n<\/span> {<\/span><\/p>\n

                      \u00a0\u00a0“name”: “PowerShell Dev Container”,<\/span><\/p>\n

                      \u00a0\u00a0“dockerFile”: “..\/Dockerfile”,<\/span><\/p>\n

                      \u00a0\u00a0“extensions”: [<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0“ms-vscode.PowerShell”<\/span><\/p>\n

                      \u00a0\u00a0],<\/span><\/p>\n

                      \u00a0\u00a0“settings”: {<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0“terminal.integrated.shell.linux”: “\/usr\/bin\/pwsh”<\/span><\/p>\n

                      \u00a0\u00a0},<\/span><\/p>\n

                      \u00a0\u00a0“mounts”: [<\/span><\/p>\n

                      \u00a0\u00a0\u00a0\u00a0“source=${localWorkspaceFolder},target=\/workspace,type=bind”<\/span><\/p>\n

                      \u00a0\u00a0]<\/span><\/p>\n

                      }<\/span><\/p>\n

                        \n
                      1. \u00a0In this configuration:<\/span>\n
                          \n
                        • “name”<\/span>: The name of the development container environment.<\/span><\/li>\n
                        • “dockerFile”<\/span>: The path to the Dockerfile used to build the container.<\/span><\/li>\n
                        • “extensions”<\/span>: Specifies the VS Code extensions to install inside the container. In this case, we are installing the PowerShell extension.<\/span><\/li>\n
                        • “settings”<\/span>: Configures settings for VS Code inside the container, such as specifying PowerShell as the default terminal shell.<\/span><\/li>\n
                        • “mounts”<\/span>: This mounts the local workspace folder to the <\/span>\/workspace<\/span> directory inside the container, allowing you to access your project files.<\/span><\/li>\n<\/ul>\n<\/li>\n
                        • Opening the Project in the Container<\/b>:<\/span>
                          \n<\/span> Once the <\/span>devcontainer.json<\/span> file is in place, open VS Code and use the command palette (Ctrl+Shift+P) to select \u201cRemote-Containers: Open Folder in Container.\u201d Choose your project folder, and VS Code will build the Docker container using the Dockerfile and the configuration from the <\/span>devcontainer.json<\/span> file.<\/span>
                          \n<\/span>
                          \n<\/span> After a few moments, VS Code will connect to the container and open your project inside it. The terminal in VS Code will automatically use PowerShell, and you can start working with your scripts as if you were working on a local machine.<\/span><\/li>\n<\/ol>\n

                          Working with PowerShell Inside the Container<\/b><\/h3>\n

                          With the container open in VS Code, you can now interact with it just like you would with any local development environment. Here are some of the tasks you can perform:<\/span><\/p>\n

                          Running PowerShell Scripts<\/b>:<\/span>
                          \n<\/span> Open the integrated terminal in VS Code (Ctrl+`), and you\u2019ll be inside PowerShell. You can run PowerShell commands and scripts directly from the terminal. For example:<\/span>
                          \n<\/span>
                          \n<\/span> Get-Command<\/span><\/p>\n

                            \n
                          1. \u00a0This command will list all the available cmdlets inside the container.<\/span><\/li>\n<\/ol>\n

                            Installing PowerShell Modules<\/b>:<\/span>
                            \n<\/span> If you need to install additional PowerShell modules inside the container, you can do so using the <\/span>Install-Module<\/span> cmdlet. For example, to install the Azure PowerShell module, run:<\/span>
                            \n<\/span>
                            \n<\/span> Install-Module -Name Az -Force -Scope CurrentUser<\/span><\/p>\n

                              \n
                            1. \u00a0This will install the Az module, which allows you to interact with Azure resources directly from PowerShell.<\/span><\/li>\n
                            2. Debugging PowerShell Scripts<\/b>:<\/span>
                              \n<\/span> VS Code\u2019s integrated debugging features work seamlessly with PowerShell inside containers. You can set breakpoints, step through your code, and inspect variables. This makes it easy to test and troubleshoot your PowerShell scripts in an isolated environment.<\/span><\/li>\n
                            3. Testing in Isolated Environments<\/b>:<\/span>
                              \n<\/span> Containers provide the ability to create isolated testing environments that mimic production setups. For example, if you are working with a PowerShell script that interacts with a database or a cloud service, you can use Docker Compose to create additional services like a database, making it easier to test your scripts in a production-like environment.<\/span><\/li>\n<\/ol>\n

                              Advanced Docker Usage for PowerShell Development in Visual Studio Code<\/b><\/h2>\n

                              In the first two parts of this series, we’ve covered how Docker containers can be used to create isolated, reproducible environments for PowerShell development. We\u2019ve set up a basic PowerShell container, configured it within Visual Studio Code (VS Code), and explored how to interact with and develop inside containers. In this part, we will dive into more advanced usage of Docker containers for PowerShell development, focusing on multi-container setups, debugging, and integrating Docker containers into Continuous Integration\/Continuous Deployment (CI\/CD) workflows.<\/span><\/p>\n

                              These advanced practices are essential for developers working in more complex environments or those looking to automate testing, improve scalability, and integrate Docker into their development and deployment pipelines.<\/span><\/p>\n

                              Working with Multi-Container Setups Using Docker Compose<\/b><\/h3>\n

                              For many development scenarios, a single container may not be enough. Often, you will need multiple services running together. For example, you might need a database container alongside your PowerShell container for testing database interactions. Docker Compose is an excellent tool for managing multi-container applications. It allows you to define and manage multiple containers in a single configuration file.<\/span><\/p>\n

                              1. Setting Up Docker Compose<\/b><\/h4>\n

                              Docker Compose allows you to define multiple containers, their configurations, networking, and volumes in a single YAML file. This is especially useful when working on complex applications that require several services to interact with each other, such as a PowerShell script that queries a database or interacts with cloud services.<\/span><\/p>\n

                              To get started with Docker Compose:<\/span><\/p>\n

                              Create a <\/b>Docker-Compose. yml<\/b> File<\/b>
                              \n<\/b>
                              \n<\/b> In your project\u2019s root directory, create a <\/span>docker-compose.yml<\/span> file. This file defines the services, networks, and volumes used by your containers. Here is an example of a simple <\/span>Docker Compose. YML<\/span> file that includes a PowerShell container along with a MongoDB container:<\/span>
                              \n<\/span>
                              \n<\/span> version: ‘3.8’<\/span><\/p>\n

                               <\/p>\n

                              Services:<\/span><\/p>\n

                              \u00a0\u00a0Powershell-dev:<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0Build:<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0Context: .<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0dockerfile: Dockerfile<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0Volumes:<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– .:\/workspace<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0command: pwsh<\/span><\/p>\n

                               <\/p>\n

                              \u00a0\u00a0Mongo:<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0Image: mongo: latest<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0Ports:<\/span><\/p>\n

                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– “27017:27017”<\/span><\/p>\n

                               <\/p>\n

                                \n
                              1. \u00a0In this example:<\/span>\n
                                  \n
                                • The <\/span>PowerShell-Dev<\/span> service is built from the Dockerfile in the current directory.<\/span><\/li>\n
                                • The <\/span>mongo<\/span> service is based on the latest version of the MongoDB image and exposes port 27017.<\/span><\/li>\n<\/ul>\n<\/li>\n<\/ol>\n

                                  Running Docker Compose<\/b>
                                  \n<\/b>
                                  \n<\/b> To start both containers, use the following command:<\/span>
                                  \n<\/span>
                                  \n<\/span> docker-compose up<\/span><\/p>\n

                                    \n
                                  1. \u00a0This will start the PowerShell container and the MongoDB container simultaneously. You can now interact with both services inside the containers.<\/span><\/li>\n<\/ol>\n

                                    2. Accessing the Containers<\/b><\/h4>\n

                                    Once the containers are running, you can access them directly using VS Code’s Remote – Containers extension.<\/span><\/p>\n

                                      \n
                                    1. Open the Command Palette (Ctrl+Shift+P) in VS Code.<\/span><\/li>\n
                                    2. Select <\/span>Remote-Containers: Attach to Running Container…<\/b> and choose the <\/span>powershell-dev<\/span> container from the list.<\/span><\/li>\n
                                    3. VS Code will open the container, and you can use the integrated terminal to run PowerShell commands or scripts that interact with MongoDB.<\/span><\/li>\n<\/ol>\n

                                      With this setup, you can test PowerShell scripts that interact with MongoDB or other services that you may add to your <\/span>docker-compose.yml<\/span> file.<\/span><\/p>\n

                                      3. Scaling Services with Docker Compose<\/b><\/h4>\n

                                      Docker Compose also allows you to scale services if needed. For instance, if you need to run multiple instances of MongoDB or other services for load testing, you can scale the containers using the following command:<\/span><\/p>\n

                                      docker-compose up –scale mongo=3<\/span><\/p>\n

                                       <\/p>\n

                                      This will start three instances of the MongoDB container, allowing you to simulate a more complex environment.<\/span><\/p>\n

                                      Debugging PowerShell Scripts Inside Containers<\/b><\/h3>\n

                                      One of the most valuable features of Visual Studio Code is its ability to debug scripts directly inside containers. This is particularly useful when working in isolated environments, as you can quickly diagnose issues and ensure that your code behaves as expected in a production-like setup.<\/span><\/p>\n

                                      1. Setting Up Debugging for PowerShell<\/b><\/h4>\n

                                      To start debugging PowerShell scripts inside a Docker container, follow these steps:<\/span><\/p>\n

                                        \n
                                      1. Install PowerShell Extension in VS Code<\/b>: Ensure that the <\/span>PowerShell extension<\/b> is installed in VS Code, both locally and inside the container (which we configured earlier).<\/span><\/li>\n<\/ol>\n

                                        Creating a Launch Configuration<\/b>
                                        \n<\/b>
                                        \n<\/b> To set up debugging, you need to create a <\/span>.vscode\/launch.json<\/span> file in your project. This file contains the configuration for running and debugging your PowerShell scripts. Here’s an example of a simple launch configuration:<\/span>
                                        \n<\/span>
                                        \n<\/span> {<\/span><\/p>\n

                                        \u00a0\u00a0“version”: “0.2.0”,<\/span><\/p>\n

                                        \u00a0\u00a0“configurations”: [<\/span><\/p>\n

                                        \u00a0\u00a0\u00a0\u00a0{<\/span><\/p>\n

                                        \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0“type”: “PowerShell”,<\/span><\/p>\n

                                        \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0“request”: “launch”,<\/span><\/p>\n

                                        \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0“name”: “Launch PowerShell Script”,<\/span><\/p>\n

                                        \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0“script”: “${workspaceFolder}\/myscript.ps1”,<\/span><\/p>\n

                                        \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0“args”: []<\/span><\/p>\n

                                        \u00a0\u00a0\u00a0\u00a0}<\/span><\/p>\n

                                        \u00a0\u00a0]<\/span><\/p>\n

                                        }<\/span><\/p>\n

                                          \n
                                        1. \u00a0This configuration allows you to launch and debug a PowerShell script named <\/span>myscript.ps1<\/span> from the VS Code editor.<\/span><\/li>\n
                                        2. Starting Debugging<\/b>
                                          \n<\/b>
                                          \n<\/b> Once the <\/span>launch.json<\/span> file is in place, you can start debugging your script by going to the Run panel in VS Code and clicking <\/span>Start Debugging<\/b> or pressing F5. You can now set breakpoints, step through your code, and inspect variables just as you would in any local development environment.<\/span>
                                          \n<\/span>
                                          \n<\/span> When you are debugging inside a Docker container, VS Code will connect to the container and run the script in the isolated environment. This ensures that you are testing the script in the same conditions as it would run in production.<\/span><\/li>\n<\/ol>\n

                                          Integrating Docker Containers into CI\/CD Pipelines<\/b><\/h3>\n

                                          Docker containers provide a seamless way to integrate your development environments into CI\/CD (Continuous Integration\/Continuous Deployment) pipelines. By using the same Docker images locally and in your CI\/CD system, you ensure that your code is tested and deployed in a consistent environment.<\/span><\/p>\n

                                          1. Using Docker with GitHub Actions<\/b><\/h4>\n

                                          GitHub Actions is a powerful CI\/CD tool that allows you to automate your workflows. Here is an example of how you can set up a GitHub Actions workflow to build and test a PowerShell script inside a Docker container:<\/span><\/p>\n

                                          Creating the Workflow Configuration<\/b>
                                          \n<\/b>
                                          \n<\/b> Create a <\/span>.github\/workflows\/ci.yml<\/span> file in your repository with the following content:<\/span>
                                          \n<\/span>
                                          \n<\/span> name: CI Pipeline<\/span><\/p>\n

                                           <\/p>\n

                                          On:<\/span><\/p>\n

                                          \u00a0\u00a0Push:<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0Branches:<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– main<\/span><\/p>\n

                                           <\/p>\n

                                          Jobs:<\/span><\/p>\n

                                          \u00a0\u00a0Build:<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0runs-on: ubuntu-latest<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0Steps:<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– name: Checkout code<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0uses: actions\/checkout@v2<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– name: Build Docker image<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0run: |<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0docker build -t powershell-dev.<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– name: Run PowerShell script<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0run: |<\/span><\/p>\n

                                          \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0docker run –rm powershell-dev pwsh -Command “.\/scripts\/test.ps1”<\/span><\/p>\n

                                            \n
                                          1. \u00a0In this configuration:<\/span>\n
                                              \n
                                            • The workflow is triggered when code is pushed to the <\/span>main<\/span> branch.<\/span><\/li>\n
                                            • The Docker image is built using the <\/span>Dockerfile<\/span> in the root of the repository.<\/span><\/li>\n
                                            • The PowerShell script <\/span>test.ps1<\/span> is executed inside the container using <\/span>docker run<\/span>.<\/span><\/li>\n<\/ul>\n<\/li>\n
                                            • Running the Workflow<\/b>
                                              \n<\/b>
                                              \n<\/b> When code is pushed to the <\/span>main<\/span> branch, GitHub Actions will automatically trigger this workflow. It will build the Docker image, run the PowerShell script inside the container, and report the results.<\/span><\/li>\n<\/ol>\n

                                              2. Using Docker with Azure DevOps<\/b><\/h4>\n

                                              Azure DevOps also supports Docker-based CI\/CD pipelines. Here’s an example of an Azure DevOps pipeline YAML configuration:<\/span><\/p>\n

                                              Creating the Pipeline Configuration<\/b>
                                              \n<\/b>
                                              \n<\/b> Create an <\/span>azure-pipelines.yml<\/span> file in your repository with the following content:<\/span>
                                              \n<\/span>
                                              \n<\/span> Trigger:<\/span><\/p>\n

                                              \u00a0\u00a0Branches:<\/span><\/p>\n

                                              \u00a0\u00a0\u00a0\u00a0Include:<\/span><\/p>\n

                                              \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– main<\/span><\/p>\n

                                               <\/p>\n

                                              Pool:<\/span><\/p>\n

                                              \u00a0\u00a0vmImage: ‘ubuntu-latest’<\/span><\/p>\n

                                               <\/p>\n

                                              Steps:<\/span><\/p>\n

                                              – task: Docker@2<\/span><\/p>\n

                                              \u00a0\u00a0inputs:<\/span><\/p>\n

                                              \u00a0\u00a0\u00a0\u00a0command: ‘build’<\/span><\/p>\n

                                              \u00a0\u00a0\u00a0\u00a0dockerfile: ‘**\/Dockerfile’<\/span><\/p>\n

                                              \u00a0\u00a0\u00a0\u00a0tags: ‘latest’<\/span><\/p>\n

                                               <\/p>\n

                                              – script: |<\/span><\/p>\n

                                              \u00a0\u00a0\u00a0\u00a0docker run –rm powershell-dev pwsh -Command “.\/scripts\/test.ps1”<\/span><\/p>\n

                                              \u00a0\u00a0displayName: ‘Run PowerShell Script’<\/span><\/p>\n

                                                \n
                                              1. \u00a0In this configuration:<\/span>\n
                                                  \n
                                                • The pipeline is triggered on changes to the <\/span>main<\/span> branch.<\/span><\/li>\n
                                                • The Docker image is built using the <\/span>Dockerfile<\/span>.<\/span><\/li>\n
                                                • The PowerShell script is executed inside the container.<\/span><\/li>\n<\/ul>\n<\/li>\n
                                                • Running the Pipeline<\/b>
                                                  \n<\/b>
                                                  \n<\/b> Every time you push changes to the <\/span>main<\/span> branch, Azure DevOps will automatically run this pipeline, ensuring that your PowerShell scripts are tested inside the Docker container.<\/span><\/li>\n<\/ol>\n

                                                  Best Practices and Performance Optimization for Docker Containers in PowerShell Development<\/b><\/h2>\n

                                                  In the previous parts of this series, we’ve discussed how Docker containers can enhance PowerShell development in Visual Studio Code, particularly through the use of isolated environments for testing and debugging, multi-container setups, and seamless integration into Continuous Integration\/Continuous Deployment (CI\/CD) workflows. In this final part, we will dive into best practices for working with Docker containers and how to optimize their performance for PowerShell development. We will also cover some tips for managing and scaling your Dockerized development environments.<\/span><\/p>\n

                                                  Best Practices for Managing Docker Containers in Development Environments<\/b><\/h3>\n

                                                  While Docker provides great flexibility and control, it’s essential to follow best practices to ensure that your containers are efficient, maintainable, and scalable. Below are some key best practices for managing Docker containers effectively in PowerShell development workflows.<\/span><\/p>\n

                                                  1. Keep Dockerfiles Simple and Modular<\/b><\/h4>\n

                                                  One of the best practices when working with Docker is to keep your Dockerfiles simple and modular. Avoid adding unnecessary commands or installing unnecessary packages. The more streamlined your Dockerfile is, the quicker it will build, and the smaller your image size will be. Here are a few tips:<\/span><\/p>\n

                                                  Minimize Layers<\/b>: Each <\/span>RUN<\/span> command in a Dockerfile creates a new layer. To reduce image size, try to group related commands into a single <\/span>RUN<\/span> statement. For example, instead of running multiple <\/span>apt-get install<\/span> commands, combine them in one:<\/span>
                                                  \n<\/span>
                                                  \n<\/span> RUN apt-get update && \\<\/span><\/p>\n

                                                  \u00a0\u00a0\u00a0\u00a0apt-get install -y git curl && \\<\/span><\/p>\n

                                                  \u00a0\u00a0\u00a0\u00a0rm -rf \/var\/lib\/apt\/lists\/*<\/span><\/p>\n

                                                    \n
                                                  • <\/li>\n
                                                  • Use Official Images<\/b>: Always try to use official and well-maintained images as base images, such as the official PowerShell or Ubuntu images. These images are optimized for performance and security.<\/span><\/li>\n<\/ul>\n

                                                    Clean Up After Installation<\/b>: After installing dependencies, always clean up unnecessary files (e.g., package cache, temp files) to reduce image size.<\/span>
                                                    \n<\/span>
                                                    \n<\/span> RUN apt-get update && \\<\/span><\/p>\n

                                                    \u00a0\u00a0\u00a0\u00a0apt-get install -y git curl && \\<\/span><\/p>\n

                                                    \u00a0\u00a0\u00a0\u00a0rm -rf \/var\/lib\/apt\/lists\/* \\<\/span><\/p>\n

                                                    \u00a0\u00a0\u00a0\u00a0&& apt-get clean<\/span><\/p>\n

                                                    2. Leverage <\/b>.dockerignore<\/b> to Exclude Unnecessary Files<\/b><\/h4>\n

                                                    Just like a <\/span>.gitignore<\/span> file is used to exclude files from version control, a <\/span>.dockerignore<\/span> file helps exclude unnecessary files from being included in your Docker images. This can significantly reduce the size of your images and speed up the build process.<\/span><\/p>\n

                                                    For example, you may want to exclude files like:<\/span><\/p>\n

                                                      \n
                                                    • .git<\/span> directories<\/span><\/li>\n
                                                    • Build directories (e.g., <\/span>bin\/<\/span>, <\/span>obj\/<\/span>)<\/span><\/li>\n
                                                    • Temporary files (e.g., <\/span>.vscode\/ ., DS_Store<\/span>)<\/span><\/li>\n<\/ul>\n

                                                      Here\u2019s a simple <\/span>.dockerignore<\/span> file:<\/span><\/p>\n

                                                      .git<\/span><\/p>\n

                                                      .vscode<\/span><\/p>\n

                                                      node_modules<\/span><\/p>\n

                                                      *.log<\/span><\/p>\n

                                                      *.tmp<\/span><\/p>\n

                                                       <\/p>\n

                                                      This ensures that only relevant files are included in your Docker image, helping reduce bloat and improve build performance.<\/span><\/p>\n

                                                      3. Use Docker Volumes for Persistent Data<\/b><\/h4>\n

                                                      When working with containers, it’s essential to understand the difference between data inside the container and data that persists beyond the container’s lifecycle. By default, data stored inside a container is ephemeral. This means that if the container is removed, the data will be lost. To avoid this, use Docker volumes to store data persistently.<\/span><\/p>\n

                                                      For example, if you\u2019re working with a PowerShell script that interacts with a database, you can store database data in a volume:<\/span><\/p>\n

                                                      Services:<\/span><\/p>\n

                                                      \u00a0\u00a0Powershell-dev:<\/span><\/p>\n

                                                      \u00a0\u00a0\u00a0\u00a0image: custom-powershell<\/span><\/p>\n

                                                      \u00a0\u00a0\u00a0\u00a0Volumes:<\/span><\/p>\n

                                                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– .\/workspace:\/workspace<\/span><\/p>\n

                                                      \u00a0\u00a0\u00a0\u00a0\u00a0\u00a0– db_data:\/var\/lib\/mongodb<\/span><\/p>\n

                                                       <\/p>\n

                                                      Volumes:<\/span><\/p>\n

                                                      \u00a0\u00a0db_data:<\/span><\/p>\n

                                                       <\/p>\n

                                                      In this example:<\/span><\/p>\n

                                                        \n
                                                      • .\/workspace:\/workspace<\/span> mounts the local project directory to the container, so your scripts are accessible.<\/span><\/li>\n
                                                      • db_data:\/var\/lib\/mongodb<\/span> stores the MongoDB data in a persistent volume.<\/span><\/li>\n<\/ul>\n

                                                        This practice is particularly useful when running multi-container setups (e.g., databases, caches) or when dealing with large datasets that need to persist across container restarts.<\/span><\/p>\n

                                                        4. Tag Docker Images for Versioning and Updates<\/b><\/h4>\n

                                                        Tagging Docker images properly is essential to ensure versioning and maintain a clear update strategy. Using tags helps you manage different versions of your images and ensures that you can revert to a previous version if necessary.<\/span><\/p>\n

                                                        For example, when building a new image, you can tag it with both the <\/span>latest<\/span> tag and a version number:<\/span><\/p>\n

                                                        Docker build -t custom-powershell: latest.<\/span><\/p>\n

                                                        Docker build -t custom-powershell:v1.0.<\/span><\/p>\n

                                                         <\/p>\n

                                                        This makes it clear which version of the image you are using in your environment. Always avoid using the <\/span>latest<\/span> tag exclusively in production environments, as it can lead to unpredictable results. Instead, always specify an explicit version tag when deploying.<\/span><\/p>\n

                                                        5. Keep Your Containers Lightweight<\/b><\/h4>\n

                                                        The key to a successful containerized environment is to keep the containers as lightweight as possible. Heavy containers that include too many dependencies or unnecessary components can affect both performance and manageability. You can follow these strategies to ensure lightweight containers:<\/span><\/p>\n

                                                        Use Minimal Base Images<\/b>: Choose base images that are minimal but functional for your use case. For example, <\/span>Alpine<\/span> is a very lightweight image based on Alpine Linux, which is perfect for many use cases where you don\u2019t need a full operating system.<\/span>
                                                        \n<\/span>
                                                        \n<\/span> FROM mcr.microsoft.com\/powershell:alpine<\/span><\/p>\n

                                                          \n
                                                        • <\/li>\n
                                                        • Remove Unnecessary Dependencies<\/b>: Install only the dependencies you need, and remove any that aren’t essential. For example, avoid installing global packages unless necessary.<\/span><\/li>\n<\/ul>\n

                                                          6. Security Best Practices<\/b><\/h4>\n

                                                          When working with Docker containers, security should always be a priority. Here are a few key practices to improve the security of your Docker containers:<\/span><\/p>\n

                                                            \n
                                                          • Use Official or Verified Images<\/b>: Always use official or well-maintained images to avoid the risk of vulnerabilities introduced by untrusted images.<\/span><\/li>\n<\/ul>\n

                                                            Run Containers as Non-Root User<\/b>: By default, containers run with root privileges. To enhance security, create a non-root user and run your application with that user:<\/span>
                                                            \n<\/span>
                                                            \n<\/span> RUN useradd -ms \/bin\/bash devuser<\/span><\/p>\n

                                                            USER devuser<\/span><\/p>\n

                                                              \n
                                                            • <\/li>\n
                                                            • Scan Docker Images for Vulnerabilities<\/b>: Regularly scan your images for vulnerabilities using Docker security tools, such as Docker Scout or third-party tools like Clair or Trivy.<\/span><\/li>\n<\/ul>\n

                                                              Optimizing Performance of Docker Containers for PowerShell Development<\/b><\/h3>\n

                                                              Now that we\u2019ve covered best practices for managing containers, let\u2019s focus on optimizing the performance of Docker containers, specifically when used in PowerShell development workflows.<\/span><\/p>\n

                                                              1. Minimize Resource Usage<\/b><\/h4>\n

                                                              When running containers, especially in resource-constrained environments, it’s important to minimize resource usage (CPU, memory). Here are some strategies:<\/span><\/p>\n

                                                              Limit CPU and Memory Resources<\/b>: You can limit the amount of CPU and memory resources assigned to a container by using Docker\u2019s– <\/span>memory<\/span> and– <\/span>cpus<\/span> flags. For example, to limit a container to use no more than 1GB of memory and one CPU core:<\/span>
                                                              \n<\/span>
                                                              \n<\/span> docker run –memory=”1g” –cpus=”1″ powershell-dev<\/span><\/p>\n

                                                              Optimize Docker Compose for Resource Efficiency<\/b>: When using Docker Compose, you can specify limits on services to ensure that containers do not consume too many resources, affecting the performance of your host system.<\/span>
                                                              \n<\/span>
                                                              \n<\/span> Services:<\/span><\/p>\n

                                                              \u00a0\u00a0Powershell-dev:<\/span><\/p>\n

                                                              \u00a0\u00a0\u00a0\u00a0Build: .<\/span><\/p>\n

                                                              \u00a0\u00a0\u00a0\u00a0mem_limit: 1g<\/span><\/p>\n

                                                              \u00a0\u00a0\u00a0\u00a0cpu_count: 1<\/span><\/p>\n

                                                              2. Use Caching for Faster Builds<\/b><\/h4>\n

                                                              Docker builds can be slow, especially when the Dockerfile involves installing multiple dependencies. Docker\u2019s layer caching mechanism can significantly speed up build times by reusing layers from previous builds.<\/span><\/p>\n

                                                              To take full advantage of caching:<\/span><\/p>\n

                                                                \n
                                                              • Place commands that change infrequently at the top of your Dockerfile (e.g., <\/span>apt-get update<\/span> and <\/span>apt-get install<\/span>).<\/span><\/li>\n
                                                              • Place commands that change frequently (e.g., copying project files) towards the bottom of the Dockerfile.<\/span><\/li>\n<\/ul>\n

                                                                This ensures that Docker can reuse cached layers and avoid rebuilding parts of the image that haven\u2019t changed.<\/span><\/p>\n

                                                                3. Leverage BuildKit for Faster Builds<\/b><\/h4>\n

                                                                Docker introduced BuildKit to speed up the building process and improve caching. To enable BuildKit, set the environment variable <\/span>DOCKER_BUILDKIT=1<\/span> before running the <\/span>docker build<\/span> command:<\/span><\/p>\n

                                                                DOCKER_BUILDKIT=1 docker build -t custom-powershell.<\/span><\/p>\n

                                                                 <\/p>\n

                                                                BuildKit optimizes the Docker build process by performing parallel builds, better caching, and improved layer management. This can make a noticeable difference in the time it takes to build large images.<\/span><\/p>\n

                                                                4. Monitor Container Performance<\/b><\/h4>\n

                                                                Monitoring is an important aspect of performance optimization. Docker provides tools to monitor container performance, such as <\/span>docker stats<\/span>, which shows real-time statistics of resource usage. For example:<\/span><\/p>\n

                                                                Dockerstats powershell-dev<\/span><\/p>\n

                                                                 <\/p>\n

                                                                This command shows the CPU and memory usage of the <\/span>PowerShell-Dev<\/span> container, helping you identify performance bottlenecks.<\/span><\/p>\n

                                                                Conclusion<\/b><\/h2>\n

                                                                Docker containers are a powerful tool for PowerShell developers, enabling reproducible, isolated environments for testing, debugging, and running scripts. By following best practices such as keeping Dockerfiles simple, using volumes for persistent data, and optimizing resource usage, you can ensure that your containers remain efficient, secure, and scalable. Additionally, performance optimization techniques like using BuildKit, leveraging caching, and monitoring container resource usage can help improve the speed and responsiveness of your containers.<\/span><\/p>\n

                                                                By integrating Docker into your development, testing, and CI\/CD workflows, you can streamline the process of building, deploying, and managing PowerShell scripts consistently and reliably. With Docker and Visual Studio Code, you are empowered to create efficient and flexible development environments that allow you to focus on writing and testing PowerShell code, rather than managing complex local environments.<\/span><\/p>\n

                                                                This concludes our series on using Docker containers for PowerShell development in Visual Studio Code. With the tools and strategies discussed in these four parts, you’re equipped to take your development workflows to the next level. Happy coding!<\/span><\/p>\n

                                                                 <\/p>\n","protected":false},"excerpt":{"rendered":"

                                                                In modern software development, containers have become an essential tool for creating isolated and reproducible environments. The integration of Docker containers within Visual Studio Code (VS Code) takes this a step further by providing a seamless and powerful development experience. Containers help address several challenges faced by developers, including environment consistency, dependency management, and the complexity of cross-platform development. VS Code\u2019s extensibility allows developers to interact with Docker containers directly from the editor, enhancing productivity and enabling smoother workflows. In this article, we will explore how Docker containers integrate with…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[709],"tags":[],"class_list":["post-4677","post","type-post","status-publish","format-standard","hentry","category-devops"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t