Azure DevOps速率限制

Question

目标是在GO中使用其许可证和项目权利来检索Azure Devops用户。

我正在使用 Microsoft SDK 。

我们的Azure DevOps组织拥有1500多名用户。因此，当我请求每个用户授权时，我的错误消息是 azure devops速率限制 =＆gt; 443：阅读：连接重置，但是

，用100/200限制顶部，当然可以。

，但是 限制。或者也许使用 heimdall 。

您对一个好设计师的建议是什么？

谢谢。

这是代码：

package main

import (
    "context"
    "fmt"
    "github.com/microsoft/azure-devops-go-api/azuredevops"
    "github.com/microsoft/azure-devops-go-api/azuredevops/memberentitlementmanagement"
    "log"
    "runtime"
    "sync"
    "time"
)

var organizationUrl = "https://dev.azure.com/xxx"
var personalAccessToken = "xxx"

type User struct {
    DisplayName         string
    MailAddress         string
    PrincipalName       string
    LicenseDisplayName  string
    Status              string
    GroupAssignments    string
    ProjectEntitlements []string
    LastAccessedDate    azuredevops.Time
    DateCreated         azuredevops.Time
}

func init() {
    runtime.GOMAXPROCS(runtime.NumCPU()) // Try to use all available CPUs.
}

func main() {
    // Time measure
    defer timeTrack(time.Now(), "Fetching Azure DevOps Users License and Projects")

    // Compute context
    fmt.Println("Version", runtime.Version())
    fmt.Println("NumCPU", runtime.NumCPU())
    fmt.Println("GOMAXPROCS", runtime.GOMAXPROCS(0))
    fmt.Println("Starting concurrent calls...")

    // Create a connection to your organization
    connection := azuredevops.NewPatConnection(organizationUrl, personalAccessToken)

    // New context
    ctx := context.Background()

    // Create a member client
    memberClient, err := memberentitlementmanagement.NewClient(ctx, connection)
    if err != nil {
        log.Fatal(err)
    }

    // Request all users
    top := 10000
    skip := 0
    filter := "Id"
    response, err := memberClient.GetUserEntitlements(ctx, memberentitlementmanagement.GetUserEntitlementsArgs{
        Top:        &top,
        Skip:       &skip,
        Filter:     &filter,
        SortOption: nil,
    })

    usersLen := len(*response.Members)

    allUsers := make(chan User, usersLen)

    var wg sync.WaitGroup
    wg.Add(usersLen)

    for _, user := range *response.Members {
        go func(user memberentitlementmanagement.UserEntitlement) {
            defer wg.Done()

            var userEntitlement = memberentitlementmanagement.GetUserEntitlementArgs{UserId: user.Id}
            account, err := memberClient.GetUserEntitlement(ctx, userEntitlement)
            if err != nil {
                log.Fatal(err)
            }

            var GroupAssignments string
            var ProjectEntitlements []string

            for _, assignment := range *account.GroupAssignments {
                GroupAssignments = *assignment.Group.DisplayName
            }

            for _, userProject := range *account.ProjectEntitlements {
                ProjectEntitlements = append(ProjectEntitlements, *userProject.ProjectRef.Name)
            }

            allUsers <- User{
                DisplayName:         *account.User.DisplayName,
                MailAddress:         *account.User.MailAddress,
                PrincipalName:       *account.User.PrincipalName,
                LicenseDisplayName:  *account.AccessLevel.LicenseDisplayName,
                DateCreated:         *account.DateCreated,
                LastAccessedDate:    *account.LastAccessedDate,
                GroupAssignments:    GroupAssignments,
                ProjectEntitlements: ProjectEntitlements,
            }
        }(user)
    }

    wg.Wait()
    close(allUsers)
    for eachUser := range allUsers {
        fmt.Println(eachUser)
    }
}

func timeTrack(start time.Time, name string) {
    elapsed := time.Since(start)
    log.Printf("%s took %s", name, elapsed)
}

Answer 1

您可以编写 getUserentitrempt 函数的自定义版本。

它不使用任何私人成员。

获得 http.Response 后，您可以检查 retry-terry-fefter 标题，并在存在的情况下延迟下一个环的迭代。

https：https：// github。 com/microsoft/azure-devops-go-api/blob/dev/azuredevops/memberentitementmanagement.cliant.go＃l306

您的代码中的PS同时发生是多余的，可以删除。

更新 - 解释并发问题：

您无法轻松在并发代码中实现限制速率。如果您顺序执行所有请求，并在移至下一个响应之前，在每个响应中检查标题，将会更简单。

通过并行执行：1）您不能依靠重试标题值，因为您可能会同时返回另一个值的另一个请求执行。 2）您不能将延迟应用于其他请求，因为其中一些已经在进行中。

Answer 2

对于真正的解决方案，我不再使用SDK并使用直接
使用自定义HTTP处理程序的REST API调用，该处理程序将支持率
限制。或者也许使用Heimdall。

您是说要通过直接使用REST API避免速率限制吗？

如果是这样，那么您的想法将不起作用。

大多数REST API都可以通过客户端库访问，如果您基于REST API或其他基于REST API的内容使用SDK，它当然会达到速率限制。

由于速率限制是基于用户的，因此我建议您可以根据多个用户完成操作（前提是您的请求不是阻止IP的服务器太多）。