dotnet-samples | Contains samples and documentation for libraries and tools | SDK library

Some of the classes like GraphUserPrincipalNameCreationContext aren't currently available in the python client API. They are working on it. You can track the issue here in GitHub repo: https://github.com/microsoft/azure-devops-python-api/issues/176

You can use User Entitlements - Add REST API for azure devops instead of it's Graph API. You can use the following python client for this purpose:

https://github.com/microsoft/azure-devops-python-api/tree/dev/azure-devops/azure/devops/v5_0/member_entitlement_management

You can refer to the sample given in the following question to know about how to use the mentioned python client :

Unable to deserialize to object: type, KeyError: ' key: int; value: str '

GraphUserCreationContext class from the python client for azure devops REST API accepts only one input parameter which is StorageKey. Hence, whatever you provide as an input parameter to that function, be it a UPN or ID, it is set as a storage key.

If you print the addAADUserContext object, you will get:

You have to create each iteration (first parent then child). This is my function to create iteration:

In the Dockerfile you need to replace FROM microsoft/dotnet:2.1-runtime AS runtime with FROM microsoft/dotnet:2.1-runtime-stretch-slim-arm32v7 AS runtime if building the image under Windows.

When building an ASP.NET Core App, the runtime image for ARM32 is microsoft/dotnet:2.1-aspnetcore-runtime-stretch-slim-arm32v7.

Building the image on the Raspberry should work fine.

This is because microsoft/dotnet:2.1-runtime is multi-arch and docker build choses the image that matches the current processor architecture. So, when building under Windows, the resulting image will be for amd64.

Sorry, it's not able to set/modify changeset author and date by REST API in TFS. It is also easy to understand. If a source control system is easily to change this area, it seems kind of violate the version control. And the changeset history will become no reference value, we do not know if the author and the date is the real one and time checked in.

This is also documented clearly in Microsoft Docs, please take a look at below part: Using public API-based tools for higher fidelity migration You are also using the API and kind of build your own tool.

Generally these tools can provide a higher fidelity migration than a manual copy of "tip" data, but they are still relatively low fidelity. For example:

• None of them will preserve the dates of TFVC changesets.
• Many of them will not preserve the changed dates of work item revisions.
• None of them will migrate all TFS artifacts.

System.CreatedBy field can only be modified on work item creation. If the work item has multiple revisions, System.CreatedBy can not be changed by bypassing rule.

You can also find it in make an update bypassing rules:

NOTE: System.CreatedBy and System.CreatedDate can only be modified using bypass rules on work item creation, i.e. the first revision of a work item.

Since System.CreatedBy and System.CreatedDate record who and when did a work item created, it can only be updated when you create the work item.

I have SEP 14 MP1 by default in my servers. Once I removed it, docker worked.

I tried to simply disable it, but still, SEP blocks somehow.

Docker images are encapsulated filesystems. The software and files inside are not being directly installed onto your system.

You can think of a Docker image sort of the way you think of a .zip file. You can download a .zip file from somewhere, and it is a single file. Contained inside it might be one file, or dozens of files, or a nested tree of directories and files. But on your disk, it exists as one file.

A Docker image is similar (conceptually, at least... the details are more complicated).

Where images are stored varies by platform. On a Linux system, they are usually under /var/lib/docker. I don't know where they are stored on Windows, but this is a more or less opaque store. Poking around inside will not reveal very much to you anyway.

To see what you have, you should use the docker images command. It will show you the images you have stored locally.

Like I said earlier, each image may consist of multiple layers. By default, that command will only show you the top layer, which is the one you'll care about, to run containers from. Technically, there are other layers, and you can see all of them using docker images -a.

When you download an Apache image, nothing is installed on your system at all. The image file(s) are downloaded and stored. Hiding inside is Apache and everything Apache needs in order to run, but Apache is not installed onto your Windows OS anywhere.

When you want to use Apache, you would run a container. Docker takes the Apache image and, using it as a starting template, creates a running process container, inside of which Apache is running. This is isolated from your operating system. Apache is only running inside of the container.

If you run a second container from the Apache image, you now have two completely separate Apache instances running, each in their own isolated filesystem environment.

If you just want to poke around in the container filesystem, you can start the container in interactive mode, and run a shell instead of whatever it normally runs (like Apache). For instance, if you have an image apache:latest, you can do this: