{"id":1964,"date":"2022-04-22T07:40:16","date_gmt":"2022-04-22T14:40:16","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/azure-sdk\/?p=1964"},"modified":"2022-05-25T16:41:34","modified_gmt":"2022-05-25T23:41:34","slug":"introducing-the-latest-beta-versions-of-the-azure-sdk-for-go-management-modules","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/azure-sdk\/introducing-the-latest-beta-versions-of-the-azure-sdk-for-go-management-modules\/","title":{"rendered":"Introducing the latest beta versions of the Azure SDK for Go management modules"},"content":{"rendered":"

You may have heard that Go version 1.18 has been released. This release introduced support for generic code using parameterized types<\/a>. After applying new language features and learnings from user studies, we’ve released new beta versions of the Azure SDK for Go management modules. We believe the new versions will provide a better development experience.<\/p>\n

Get the latest modules<\/h2>\n

You can get the latest modules using pkg.go.dev<\/a> or view the latest source code in the Azure SDK for Go repository<\/a>. You can also find a list of all the management modules with the latest beta version on our Azure SDK Releases<\/a> page. Because the new modules apply Go generics, you’ll need to upgrade to Go 1.18 first.<\/p>\n

API changes<\/h2>\n

Generic poller for long-running operations (LROs)<\/h3>\n

We’ve removed all the non-generic poller response types for all LROs. They’re replaced with a new generic poller type armruntime.Poller[T]<\/code>. The usage of poller hasn’t changed much. You can use poller.PollUntilDone<\/code> to get the final response synchronously. Alternatively, you can use poller.Poll<\/code>, poller.Done<\/code>, and poller.Result<\/code> to implement your own polling logic. The following example shows how to use the new poller to get the final result when capturing a virtual machine.<\/p>\n

cred<\/span>, err<\/span> :=<\/span> azidentity<\/span>.NewDefaultAzureCredential<\/span>(nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\nctx<\/span> :=<\/span> context<\/span>.TODO<\/span>()\r\nclient<\/span>, err<\/span> :=<\/span> armcompute<\/span>.NewVirtualMachinesClient<\/span>(\"<subscription-id>\"<\/span>, cred<\/span>, nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\npoller<\/span>, err<\/span> :=<\/span> client<\/span>.BeginCapture<\/span>(ctx<\/span>,\r\n    \"<resource-group-name>\"<\/span>,\r\n    \"<vm-name>\"<\/span>,\r\n    armcompute.VirtualMachineCaptureParameters<\/span>{\r\n        DestinationContainerName<\/span>: to<\/span>.Ptr<\/span>(\"<destination-container-name>\"<\/span>),\r\n        OverwriteVhds<\/span>:            to<\/span>.Ptr<\/span>(true<\/span>),\r\n        VhdPrefix<\/span>:                to<\/span>.Ptr<\/span>(\"<vhd-prefix>\"<\/span>),\r\n    },\r\n    nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\nres<\/span>, err<\/span> :=<\/span> poller<\/span>.PollUntilDone<\/span>(ctx<\/span>, nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\n\/\/ TODO: use response item<\/span>\r\n_<\/span> =<\/span> res<\/span><\/pre>\n
Generic pager and new pager API<\/h3>\n
As was the case with the generic poller, all the non-generic pager response types for operations with paging result have been removed. They’re replaced with a new generic pager type runtime.Pager[T]<\/code>. We also simplified the pager API and provided more direct error handling. You can use pager.More<\/code> to determine if there are more result pages. Then use pager.NextPage<\/code> to fetch the next result page. The following example shows how to use new pager API to list all virtual machines in a resource group.<\/p>\n
cred<\/span>, err<\/span> :=<\/span> azidentity<\/span>.NewDefaultAzureCredential<\/span>(nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\nctx<\/span> :=<\/span> context<\/span>.TODO<\/span>()\r\nclient<\/span>, err<\/span> :=<\/span> armcompute<\/span>.NewVirtualMachinesClient<\/span>(\"<subscription-id>\"<\/span>, cred<\/span>, nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\npager<\/span> :=<\/span> client<\/span>.NewListPager<\/span>(\"<resource-group-name>\"<\/span>,\r\n    &<\/span>armcompute.VirtualMachinesClientListOptions<\/span>{Filter<\/span>: to<\/span>.Ptr<\/span>(\"<filter>\"<\/span>)})\r\nfor<\/span> pager<\/span>.More<\/span>() {\r\n    nextResult<\/span>, err<\/span> :=<\/span> pager<\/span>.NextPage<\/span>(ctx<\/span>)\r\n    if<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n        panic<\/span>(err<\/span>)\r\n    }\r\n    for<\/span> _<\/span>, v<\/span> :=<\/span> range<\/span> nextResult<\/span>.Value<\/span> {\r\n        \/\/ TODO: use page item<\/span>\r\n        _<\/span> =<\/span> v<\/span>\r\n    }\r\n}<\/pre>\n
New pattern to get raw HTTP response<\/h3>\n
The response envelope has been simplified for all the operations because a response with deserialized types is sufficient for common scenarios. Previously, you could obtain the raw HTTP response from the response envelope, but now you can get it from the request context instead. The following example shows how to get the raw HTTP response when getting info from a virtual machine.<\/code><\/p>\n
cred<\/span>, err<\/span> :=<\/span> azidentity<\/span>.NewDefaultAzureCredential<\/span>(nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\nclient<\/span>, err<\/span> :=<\/span> armcompute<\/span>.NewVirtualMachinesClient<\/span>(\"<subscription-id>\"<\/span>, cred<\/span>, nil<\/span>)\r\nif<\/span> err<\/span> !=<\/span> nil<\/span> {\r\n    panic<\/span>(err<\/span>)\r\n}\r\nvar<\/span> rawResponse<\/span> *<\/span>http.Response<\/span>\r\nctx<\/span> :=<\/span> context<\/span>.TODO<\/span>()\r\nctxWithResp<\/span> :=<\/span> runtime<\/span>.WithCaptureResponse<\/span>(ctx<\/span>, &<\/span>rawResponse<\/span>)\r\nres<\/span>, err<\/span> :=<\/span> client<\/span>.Get<\/span>(ctxWithResp<\/span>,\r\n    \"<resource-group-name>\"<\/span>,\r\n    \"<vm-name>\"<\/span>,\r\n    nil<\/span>)\r\n\/\/ TODO: use raw response<\/span>\r\n_<\/span> =<\/span> rawResponse<\/span>.Body<\/span><\/pre>\n
Generic pointer conversion helper<\/h3>\n
The new version provides generic to.Ptr[T]<\/code> and to.SliceOfPtrs[T]<\/code> for pointer conversion and removes all non-generic implementations.<\/p>\n
int32Pointer := to.Ptr[int32](2)\r\nintPointer := to.Ptr(3)\r\nstringPointer := to.Ptr(\"test\")\r\nintSlicePointer := to.SliceOfPtrs([]int{1, 2, 3})<\/code><\/pre>\n
Conclusion<\/h2>\n
In these new beta modules, we reduced the number of top-level symbols and provide simplified APIs for operations. We’ll continue to add samples and docs to familiarize developers with the latest management modules. The stable versions of the Azure SDK for Go management modules are coming soon.<\/p>\n
Feedback<\/h2>\n
We encourage you to upgrade to these new beta versions and always welcome your feedback. For feature requests, bug reports, or general support, open an issue<\/a> in the Azure SDK for Go repository. For more information on how we triage issues, see Azure SDK GitHub Issue Support Process<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
You may have heard that Go version 1.18 has been released. This release introduced support for generic code using parameterized types. After applying new language features and learnings from user studies, we’ve released new beta versions of the Azure SDK for Go management modules. We believe the new versions will provide a better development experience. […]<\/p>\n","protected":false},"author":88503,"featured_media":1970,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[750,706,810,811,807],"class_list":["post-1964","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-azure-sdk","tag-azure-sdk","tag-azuresdk","tag-go","tag-golang","tag-management-libraries"],"acf":[],"blog_post_summary":"
You may have heard that Go version 1.18 has been released. This release introduced support for generic code using parameterized types. After applying new language features and learnings from user studies, we’ve released new beta versions of the Azure SDK for Go management modules. We believe the new versions will provide a better development experience. […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/posts\/1964","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/users\/88503"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/comments?post=1964"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/posts\/1964\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/media\/1970"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/media?parent=1964"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/categories?post=1964"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/azure-sdk\/wp-json\/wp\/v2\/tags?post=1964"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}