by Contributed | Feb 10, 2023 | Technology
This article is contributed. See the original author and article here.
What is Arc for Azure VMware Solution? Simply put, it exposes your Azure VMware Solution resources (VMs, networks, datastores, etc.) to the Azure portal.
Using Arc for Azure VMware Solution, those resources can be managed via the Azure portal, even though they are within your vSphere cluster running in an Azure datacenter. Even better, there is no cost to deploy Arc for Azure VMware Solution. More blogs to come on Arc for Azure VMware Solution, but if you want to get some more details check out this video from Jeremiah Megie.
First things first. Let’s get Arc for Azure VMware Solution installed into your private cloud.
You will need to collect the following information to input into the PowerShell script, which, if you use it, will make the deployment a bit more straightforward.
- Subscription ID and Resource Group where the Azure VMware Solution private cloud is deployed.
- Name of the Azure VMware Solution private cloud.
- /28 network segment for the ARC appliance.
The/28 network segment will be an NSX-T segment in the private cloud. Under the covers, the deployment script creates NSX-T segment for use by the ARC appliances. The value must be entered into the script as the gateway to the segment, followed by /28. For example, if 192.168.99.1/28 is entered, there will be a /28 NSX-T segment created with the gateway 192.168.99.1.
The other information you can get from the Overview blade of your private cloud.
Requirements
- Your private cloud must have Internet access.
- Also, because of the appliance size, ideally you would want to run this script as close to the private cloud, or from a machine inside the AVS Private Cloud.
The script can be found here;
https://virtualworkloads.com/2023/02/deploy-arc-for-azure-vmware-solution-simply-using-powershell/#script
by Contributed | Feb 9, 2023 | Technology
This article is contributed. See the original author and article here.
Last year, Reading Coach launched as part of Reading Progress in Microsoft Teams. Reading Coach provides students with personalized and independent practice that Reading Progress identifies a student has mispronounced. Reading Coach has proven to be popular not only with educators, but especially with students. We’ve heard stories from teachers of students “demanding more passages” from the teacher, and that they’ve set personal goals of improvement. To enable students to practice with content that aligns with their interests and focus, without the need for a teacher to make an assignment in Teams, we are rolling out Reading Coach as part of the Immersive Reader in many of our M365 apps. This will be available in school, consumer and work accounts, and in 116 languages and locales.
Now anyone using Immersive Reader, with any content they choose, can go to the Reading Preferences pane, enable Reading Coach to practice reading out loud and receive focused practice exercises. When the Reading Coach switch is enabled, the Play button in the Immersive Reader changes to a Microphone button. Students can select the Edit button near the Reading Coach toggle to customize parts of the coach inluding the voice, feedback style, and more. When the microphone button is selected, a dialog pops up that encourages the student to prepare to read out loud.
Once the student selects Let’s read, a 3…2…1 countdown appears, and practice begins. The student reads out loud for as long as they like while Immersive Reader “listens” to their performance. When finished, the reader selects Stop, and a reading report immediately provides data on their reading speed, accuracy, time spent reading, and any words to practice.
If the Practice Words button is clicked, the Reading Coach pops up to allow personalized practice. The Reading Coach interface is the exact same as the one in Reading Progress in Teams.
The initial set of apps that Reading Coach in Immersive Reader is available include Word for web, OneNote for web, Desktop, Mac and iPad, Teams Assignments, Flip and Minecraft Education. We expect to bring Reading Coach to more apps in the near future.
Updates to Education Insights Premium for Reading Progress
We’re excited to share that Education Insights Premium (including all Reading Progress data) is now included in all versions of Microsoft 365 Education including our no-cost Office 365 A1 license. Education Insights Premium enables education leaders to monitor student academic progress and wellbeing across their organization to help improve learning outcomes with actionable insights. Built with student safety, privacy, and security in mind, it helps schools support students while maintaining compliance with industry standards. Below is an example of a Reading Progress report across an entire school system.
Reading comprehension questions in Reading Progress
Our reading fluency app Reading Progress, launched in Microsoft Teams in fall of 2021. Reading Progress supports educators in increasing the frequency of reading fluency evaluations, helping them to differentiate more powerfully to support students on their fluency journey. The #1 request from educators and schools has been a desire to add reading comprehension questions for the student to complete after they read. We heard educator’s request and are excited to announce that we will be adding reading comprehension question support to reading progress later this year! Using Microsoft Forms technology, educators will be able to assess not only students’ fluency, but also their understanding, right in Reading Progress. Educators will be able to provide students with access to the questions prior to reading if they wish, a scaffolding strategy that can help students learn to read with purpose. The auto-grading capabilities of Microsoft Quiz will also be included to streamline grading of multiple-choice questions. We expect to have comprehension questions in private testing later in late spring of 2023.
Reading with expression (prosody) in Reading Progress
Reading fluency is composed of three pillars – speed, accuracy, and expression. The initial version of Reading Progress uses auto-detect to help track reading speed and accuracy, but historically an educator needs to listen to each student independently to gauge their expression.
With our forthcoming Expression update, Reading Progress will automatically identify students’ performance on aspects of prosody including monotone reading, long pauses, not pausing for a period or comma, voice inflection for question marks or exclamation points, and even the stress of multi-syllable words. Student expression results will be available in the teacher review experience, alongside accuracy and correct words per minute. Later, this information will be added to the student’s view of their returned work and incorporated in Insights so it can be easily monitored over time. Reading expression updates will begin rolling out to Reading Progress in late spring.
With the introduction of Reading Coach in Immersive Reader and the continued evolution of Reading Progress, we hope to maintain students’ excitement for and growth in literacy while supporting educators as they work to help every student reach their fluency goals.
Mike Tholfsen
Group Product Manager
Microsoft Education
by Contributed | Feb 8, 2023 | Technology
This article is contributed. See the original author and article here.
Managing and monitoring devices across your organization can be complicated, especially for small or medium businesses without dedicated IT staff. That’s why Surface partnered with Microsoft 365 and Intune teams to give you powerful insights that simplify managing and monitoring your devices. Our enhanced features make it easier than ever for IT admins to oversee devices via a premium dashboard experience.
Tailor-made experiences
Keep track of your Surface device inventory, view powerful insights, plan your Windows 11 update cadence, create support requests and place bulk device returns – all in one location. Using role-based access rights, we have set predefined access rights based on the M365 user’s role.
Optimized support process
Experience the enhanced process to create support requests for multiple Surface devices at once. The latest feature addition enables you to create a single request1 for multiple Surface devices for eligible device returns or repair needs.
Created to meet your needs where you are
- Surface Management Portal: If your Surface devices are enrolled through Intune, they’re automatically enrolled into the Surface Management Portal. In Endpoint Manager, go to All Services > Surface Management Portal. This includes the comprehensive feature set of Intune and Endpoint Manager.
- Microsoft Hardware Support Portal: If you have a Microsoft 365 subscription, you can have your support service needs fulfilled via the Microsoft 365 admin center. In Admin center, go to Support > Microsoft hardware support. This does not require your devices to be enrolled through Intune.
Experience the Surface centralized solutions for IT today.
References
1. Single-request support feature for multiple devices may vary based on region and device model.
by Contributed | Feb 7, 2023 | Technology
This article is contributed. See the original author and article here.
To set up Copilot as an authenticated Github Student Developer, you need to follow these steps:
Setting up your GitHub Student Account
- Create a Github account: If you don’t already have one, create a Github account. GitHub account is free, so if you have not signed up yet feel free to sign up as it is a prerequisite before you can access the Student Developer Pack. https://github.com
- Verify your student status on Github: Go to the Github Student Developer Pack and verify your student status on Github: https://education.github.com/pack
There are over 100 benefits from various companies that are packed together in the GitHub students developers pack. The GitHub student’s developer pack is strictly for students. Therefore before you can access it you would prove your student identity through your school registered email domain or through an identification process for people whose school doesn’t offer school email.
The steps below are for students with school emails. If you do not have a school-dedicated email, you can still access the GitHub student developer pack by contacting GitHub Support @ support.github.com/request.
- Step 1: Visit the student developer Pack main page (education.github.com/pack)
- Step 2: Sign Up for the student developer pack
- Step 3: Select Get Student Benefit
- Step 4: Sign-in or SignUp for a GitHub account.
- Step 5: Add your school email. This process usually needs some authentication, because a code will be sent to your school email for verification.
- Step 6: Enter the name of your school
- Step 7: Answer the questions on how you plan to use GitHub.
- Step 8: On some occasions, more proof might be required. So you might need to upload either of school identity card or any other form of proof of study validity.
- Final step: Submit the application.
Submitted applications are sometimes reviewed within the hour or at most within a day. This might take slightly longer on very few occasions depending on the volume of applications received.
Setting Up CoPilot
- Connect Copilot to Github: Go to the Copilot website and log in. Then, go to the Settings section and connect your Github account to Copilot. https://copilot.github.com
Note: If you already have a Copilot account, you can simply connect your Github account and activate your Github Student Developer Pack from your Copilot account settings.
You should now be able to use Copilot with your Github Student Developer Pack benefits.
GitHub Education is a program established by GitHub for students, teachers, and schools. The benefits of GitHub education to students and educators. The GitHub education has offers for students such as:
- GitHub Student Developer Pack (100s of FREE Software offers including $100 of Azure for Student Credit)
- GitHub Codespaces your instant dev environment in the cloud with 90 hours of compute time.
- GitHub Student Gallery (Platform where students showcase the projects they built with GitHub Student developer pack)
- GitHub Campus Experts (A program for students and educators who are building a student community in their schools. GitHub supports you in a lot of ways)
- GitHub Global Campus(Like the name illustrates, a global campus for students to learn and connect)
- GitHub Learning Lab (Free platform to grow your skill by completing fun and realistic projects)
Extensions for VSCode and Codespaces RECOMMENDED
GitHub Copilot Labs – Visual Studio Marketplace – GitHub Copilot Labs is a companion extension to GitHub Copilot that houses experimental and up-and-coming features in a sidebar.
GitHub Copilot – Visual Studio Marketplace – GitHub Copilot provides autocomplete-style suggestions from an AI pair programmer as you code. You can receive suggestions from GitHub Copilot either by starting to write the code you want to use, or by writing a natural language comment describing what you want the code to do.
by Contributed | Feb 6, 2023 | Technology
This article is contributed. See the original author and article here.
No último trimestre realizei algumas análises de performance em Web API’S desenvolvidas utilizando o ASP.NET Core, e a maioria estava com o mesmo problema: O uso incorreto dos objetos de tipo HttpClient. Percebi então que havia um padrão problemático na sua utilização.
Portanto resolvi escrever este artigo, com o intuito de ajudar os desenvolvedores a utilizarem corretamente esse tipo de objeto.
O problema
Realizar chamadas HTTP é uma tarefa simples, você só precisa criar instanciar de um objeto do tipo HttpClient, configurar algumas propriedades e pronto, você está apto a realizar sua chamada HTTP. A classe HttpClient implementa a interface IDisposable, o que significa que se você é um desenvolvedor atento, invocará o método Dispose, para que o GC possa liberar os recursos nativos apropriadamente quando essa instância for descartada.
A implementação mais comum segue um padrão parecido com:
using HttpClient client = new HttpClient();
client.BaseAddress = new Uri(“https://google.com”);
var response = await client.GetAsync(“”);
A palavra reservada using garante que o método Dispose da instância denominada client, será invocada no final do escopo do seu contexto execução. Essa sintaxe do using é relativamente nova, você pode se deparar com o seu uso da seguinte forma: using(HttpClient client = new HttpClient()){}.
O código acima deve funcionar em alguns cenários, porém, em um momento de alto volume de requisições, sua aplicação pode apresentar um aumento no tempo de resposta, chegando até a ficar indisponível, e você pode começar a observar exceções do tipo System.Net.Sockets.SocketException sendo lançadas com a mensagem: Only one usage of each socket address (protocol/network address/port) is normally permitted.
Reprodução do problema
Para que você possa entender melhor esse comportamento, uma boa estratégia é reproduzi-lo em um ambiente controlado. Para esse exemplo, você precisará do .NET Core 6.0.
Projeto
Em uma pasta de sua preferência crie um projeto utilizando o template de Console do .NET CLI, através do comando dotnet new console.
No arquivo Program.cs copie o código abaixo:
while(true)
{
using (var client = new HttpClient())
{
var result = await client.GetAsync(“http://techcommunity.microsoft.com/t5/desenvolvedores-br/bg-p/DesenvolvedoresBR”);
Console.WriteLine(result.StatusCode);
}
}
O código acima implementa um laço infinito, onde cada iteração instancia um novo HttpClient e realiza uma requisição ao endereço [http://techcommunity.microsoft.com/t5/desenvolvedores-br/bg-p/DesenvolvedoresBR].
Execute o programa de teste com o comando: dotnet run.
Netstat
Primeiro precisamos descobrir o endereço IP do nome techcommunity.microsoft.com. Para tal, abra um prompt de comando, e rode o comando nslookup techcommunity.microsoft.com. Você verá um resultado parecido com:
Server: UnKnown
Address: 192.168.86.1
Non-authoritative answer:
Name: e8318.dsca.akamaiedge.net
Addresses: 2600:1419:4e00:286::207e
2600:1419:4e00:28c::207e
96.6.215.78
Aliases: techcommunity.microsoft.com
gxcuf89792.lithium.com
techcommunity.microsoft.com.edgekey.net
Os endereços IPs que precisamos estão no campo Addresses (2600:1419:4e00:286::207e, 2600:1419:4e00:28c::207e e 96.6.215.78), guarde-os para usarmos na análise.
Deixe a aplicação rodando por alguns minutos, e termine o processo em seguida.
Utilizaremos a ferramenta netstat para visualizarmos as conexões TCP, em seguida realizaremos um filtro utilizando os endereços de IP que capturamos anteriormente. Para isso rode o comando:
netstat -an | findstr /c:”2600:1419:4e00:286::207e” /c:”2600:1419:4e00:28c::207e” /c:”96.6.215.78″
No meu caso, o resultado foi:
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65293 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65295 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65297 [2600:1419:1e00:582::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65301 [2600:1419:1e00:582::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65303 [2600:1419:1e00:582::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65305 [2600:1419:1e00:582::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65307 [2600:1419:1e00:582::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65309 [2600:1419:1e00:582::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65311 [2600:1419:1e00:582::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65313 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65315 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65318 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65320 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65322 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65324 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65326 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65328 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65330 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65332 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65336 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65338 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65371 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65373 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65375 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65377 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65380 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65382 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
TCP [2804:431:d728:afa7:61bf:a077:45be:68b3]:65384 [2600:1419:1e00:58b::207e]:80 TIME_WAIT
Repare que mesmo após parar o processo ainda existem 27 conexões no estado de: TIME_WAIT.
Este problema é conhecido como: exaustão de portas TCP ou TCP port exhaustion em inglês. Significa que todas as portas elegíveis à estabelecer a conexão TCP, estão em uso.
Time Wait
Vamos revisar o código da aplicação, para entender melhor o seu comportamento:
while(true)
{
using (var client = new HttpClient())
{
var result = await client.GetAsync(“http://techcommunity.microsoft.com/t5/desenvolvedores-br/bg-p/DesenvolvedoresBR”);
Console.WriteLine(result.StatusCode);
}
}
Quando a instrução new HttpClient() é executada, uma nova conexão TCP é criada, porém quando o método Dispose é executado no final do bloco using, a porta TCP usada pela aplicação não é liberada instantaneamente, ao invés disso, ela entra em um estado de: TIME_WAIT.
O SO mantém essas conexões por um tempo pré-definido. Por padrão, o estado de TIME_WAIT é mantido por 240 segundos, sendo configurável através da chave de registro: HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesTcpipParametersTcpTimedWaitDelay]. Mas não é uma boa ideia modificar essa chave, a não ser que você saiba muito bem o que está fazendo.
Conclusão
Para evitar o problema de exaustão de sockets, devemos criar uma conexão, e reutilizá-la o máximo de vezes possível. Uma saída é criar os objetos HttpClient como singleton ou estáticos.
No nosso exemplo o código ficaria assim:
var client = new HttpClient();
while(true)
{
var result = await client.GetAsync(“http://techcommunity.microsoft.com/t5/desenvolvedores-br/bg-p/DesenvolvedoresBR”);
Console.WriteLine(result.StatusCode);
}
Essa segunda abordagem, evitaria o problema, porém, no contexto de uma aplicação Web, ela pode trazer alguns problemas, se acontecer alguma mudança em relação a resolução de DNS, o código acima não será resiliente a ponto de resolvê-la novamente.
Para endereçar esse e outros problemas, o time do ASP.NET Core implementou a interface IHttpClientFactory.
Basicamente essa interface funciona como uma fábrica de HttpClient, ela será responsável por implementar um pool de objetos do tipo HttpMessageHandler’s, e os reutilizará.
Você pode usar essa fábrica com diferentes estratégias, a minha preferida é a nomeada de: Typed Clients ou Cliente tipado em português.
Com essa estratégia podemos criar classes de serviços específicos, e injetar um HttpClient no seu construtor através do container de injeção de dependências, por exemplo:
public class CatalogService : ICatalogService
{
private readonly HttpClient _httpClient;
private readonly string _remoteServiceBaseUrl;
public CatalogService(HttpClient httpClient)
{
_httpClient = httpClient;
}
public async Task GetCatalogItems(int page, int take,
int? brand, int? type)
{
var uri = API.Catalog.GetAllCatalogItems(_remoteServiceBaseUrl,
page, take, brand, type);
var responseString = await _httpClient.GetStringAsync(uri);
var catalog = JsonConvert.DeserializeObject(responseString);
return catalog;
}
}
Agora bastaria configurar o nosso container de injeção, na classe Program.cs, ou na classe Startup.cs em versões anteriores ao .NET 6, da seguinte forma:
services.AddHttpClient<ICatalogService, CatalogService>()
Se você tem dúvidas de como funciona a injeção de dependência no ASP.NET core, sugiro a breve leitura do artigo de um dos meus mestres aqui na Microsoft: Entendendo Injeção de Dependência com .NET.
Particularmente acho essa última abordagem muito elegante, pois, podemos isolar os pontos de integração com outros serviços, de forma desacoplada do resto do projeto. Recomendo fortemente a ler sobre as outras estratégias de criação de objetos HttpClient, viabilizadas pela IHttpClientFactory: Use o IHttpClientFactory para implementar solicitações HTTP resilientes.
Recent Comments