If you manage Parallels RAS in production, you already know the console is only part of the story. As environments grow, the real challenge becomes consistency, speed, and repeatability: onboarding and offboarding users, updating settings across farms, validating configuration changes, standardizing deployments, and responding quickly when something needs to change.
In this session, you’ll learn how to use Parallels RAS APIs and PowerShell to move those tasks out of the console and into reliable automation. We’ll break down where each API fits, how to structure scripts and workflows you can reuse across environments, and how to connect RAS to broader IT systems so common actions can be triggered from the tools your teams already use.
You’ll leave with practical examples, integration patterns, and a clearer approach to building automation that’s safe to run in production.
What we cover:
- How Parallels RAS APIs are organized, what each one is designed for, and how they work together
- Practical PowerShell patterns and samples to automate frequent admin tasks as well as more complex operational workflows
- How to use the Client API to integrate RAS into other tools, portals, and service management platforms
- What an end-to-end automation workflow looks like in a live demo, including testing and validation considerations
AI Generated·May contain errors
I'm the Director of Sales Engineering at Parallels
and I'm going to be your host today
for this technical webinar.
This webinar is part of a larger series of webinars
that we have been doing the past few months
and that we plan to do also in the next months.
But this webinar is specifically on how to use in Parallels
the APIs, not only to do backend automation,
but also like how you can automate things
on the client side through API.
As always, if there are any questions,
this is a live webinar.
We will address probably some questions
at the end of the webinar,
but I also, I'm helped today
with one of my fantastic colleagues, Paul Fisher.
He's manning the chat and the Q&A part of this live webinar.
So as always, if you have like any questions
or you want to address or help you
with something specific during this webinar,
we have Paul on the chat
and whenever we still have some little bit of time
at the end, I will also try to answer
some of the questions live today.
With that said, let's jump in.
I want to be, first of all, very thankful
for the massive registration for this webinar.
I think we hit a new record that was told
by the marketing team for this type of series.
So first of all, thank you all for joining.
We have a rather packed agenda for today.
So basically what I would like to cover
or let's say two big parts I want to cover on one hand,
how to automate the Parallels RAS backend sites.
I will do that mainly through PowerShell
and some PowerShell examples.
And then I also want to cover how you could do
the same thing with the REST API.
So if you're not into PowerShell
but you want to use like another scripting language
or another tool or another way,
you can also do it via our REST API.
But that's also something I want to cover
in the, let's say the first half of the training.
And then the second half is more about the client side.
So the Web Client API and some examples,
the Parallel Client URL Scheme that I see,
I missed a key in my slide, apologies for that.
And then also something,
I think probably nobody of you have ever heard about,
but there is also a Windows Client CLI.
So that's also something we are going to cover
and then we should have probably enough time
for Q&A at the end of this webinar.
So let's dive in.
And again, like one small reminder,
if there are like any questions or feedback,
please use the chat or the Q&A part.
My colleague Paul is there to help you answering them
and we try to answer them also at the end if time permits.
So let me start with a rather bold statement
and saying that actually everything you do
in the Parallels Console can be done through API.
So where you typically would go into Parallels,
start the Parallels Console or the Web Console,
and you would like to make some modifications
or change some data or look at some data.
All of that, everything that is done in the console
can also be done through API.
And the most easy way for me to do that
is by using our PowerShell modules,
which are part of the Parallels RAS installation.
So before we start, maybe like one disclaimer,
I'm not a developer,
so let's maybe also be very clear on that.
I'm just like, let's say a sysadmin
with some moderate PowerShell capabilities.
So you will see that all the scripts that I'm demoing
or things that I've made myself,
so these are no like official Parallels PowerShell script,
but these are like some things that I've put together
mainly as a demo or as an example
how the technology can be used.
Before we start in going to some samples,
first of all, you need to install
those PowerShell modules for Parallels.
What is important is that the binary version
that you're using for the Parallels PowerShell module
must be the same as your RAS primary connection broker.
So something you need to remember is that, for example,
if you do like an upgrade of your Parallels RAS environment
from version, I'm saying something like 21 to 21.1,
which we're going to release pretty soon,
you should also remember to upgrade
your PowerShell binaries.
By default, if you install like Parallels RAS
with a sort of like next, next, next finish install,
you will see that PowerShell modules
are also installed on your connection broker.
And of course, if you upgrade your connection broker
to the latest version,
your Parallels PowerShell binaries
will also be upgraded automatically
on your connection broker.
But if you want to run the PowerShell on another machine,
maybe you want to run it from your own laptop,
or you want to run it from sort of management station,
then you need to install it.
And there are two ways you can install it.
One way would be to run the Parallels RAS installer again.
And then of course, don't go for a next, next, next
finish install, but go for like a custom install.
And then if you just disable all the other components,
as you can see on the screenshot,
and only leave the Parallels RAS PowerShell part enabled,
that will install only the PowerShell modules
on your machine.
The alternative is actually more or less the same,
but then instead of using the installer UI,
is to just use the MSIX install method.
So I don't know if all of you are aware of that,
but you can install Parallels completely also
from common client.
So if you do like MSIX minus I, and then your binary,
and then you can specify which modules you want to install.
So for example, if you want to install
only the PowerShell module,
then you say like local equals F underscore PowerShell,
and that will just install the PowerShell module.
So this is how to actually get PowerShell
onto your machine.
The module itself is called RAS Admin,
and the current version is 4.0.
So yeah, before you start using it the first time,
you should not forget to import it.
So if you do like import module RAS Admin,
then all the RAS, sorry,
all the PowerLine comments are loaded.
And you will also see that these comments
all have a very standard structure.
So it follows, let's say, Microsoft best practices.
So it's always something like new, or get,
or update, and then RAS,
and then what you want to do.
So for example, this is like a first example,
but if you want to, for example,
log in and get a list of all the RAS brokers,
what you would need to do is,
first of all, create a session.
So the comment for that is like new RAS session,
then minus server.
If, for example, you're not connecting local,
but you're connecting from a remote machine,
then you can specify minus server,
and then the server you want to connect to.
If you don't specify anything else,
it will just prompt you for your username and your password,
then you can type in your username and password,
and the session will be open.
Of course, if you want to script this,
you want to, for example,
have no prompts for username and password.
So this is like an example code
how you could do like a full automated login.
So as you can see, I have username and password
for this session at my machine.
And then the only thing which you need to know
is that if you pass the password,
it needs to be encrypted.
So you have to convert your password into a secure string,
and then you can pass it like with new RAS session,
username, username, password,
to encrypt the password, and then server,
and then it will be open.
And then you can put your script.
So in this first example,
we do like a very simple get RAS broken,
and you will get all the results.
Important, once you have done your script,
you also have to log off.
So that can be done with the remove RAS session,
so that will log you out from the RAS session in general.
And let me switch to one of my environments,
and let me also show you the documentation in general.
So for example, if you would go to this page,
it's part of the standard docs.
So if you go to docs.parallels.com,
and then you go to the PowerShell overview,
you will get all the comments.
So there is a pretty extensive documentation.
So you see like all the comments are here.
And if I would, for example, look for the get RAS gateway,
you see, for example, it's here.
If I click on it, you get all the details,
the comments, the synopsis, the syntax.
And then even if you scroll to the bottom,
there are some examples.
So for example, you can have like an example
where you get like the details from a specific gateway,
or you get a list of all the gateways.
So if I run this script,
I just tested it out before the session started.
If I run the script, then you will see,
I log in and I get all the details.
So very intuitive, very simple way
of using the PowerShell API and getting things done.
Let me switch back to my slides,
because of course this is a very simple script.
And what I have done is I have prepared a few sample scripts
just to show you like how powerful it is.
And also to give you like an idea
how things work in a more like real life scenario.
And one thing I forgot to mention,
which I didn't need for the get,
but typically for those of you
who are a little bit familiar with the Parallels RAS console,
whenever you make modifications,
you always have to click at the end on apply
in the console to make them like executing.
And this is the same thing with the API.
So the API works more or less in the same way
as the console.
Whenever you have to make like a few changes,
the changes are not applied unless you click on the button.
In case of PowerShell,
of course, you don't click a button,
but you do like an invoke RAS apply
to make those changes active.
So that's something you should not forget,
but that's something we will show you
directly into the first example.
So the first example that I have prepared
is something which is pretty common.
You want to, for example,
create a bunch of published resources
and that would be like desktops or applications.
Maybe also something worth mentioning
is that if you're looking for some sample scripts,
and I'm not 100% sure if I've put this link into my slide,
like we can share it afterwards
or if you ask it on the chat,
or maybe Paul can even copy it on the chat,
but we also have a GitHub repository from Parallels
where there are a bunch of scripts available.
And for example, one of the scripts we have available
over there is, we call it our Citrix migration tool.
Actually, it's a PowerShell script.
And to be very correct, it's two PowerShell scripts.
One script is a script that pulls all the input
out of, for example, your Citrix configuration.
And then the second script is a little bit linked
to what I'm doing here on the screen.
It uses that data to populate the RAS site
and to create new desktops and applications
from the published apps it could fetch from Citrix.
So if you're looking for something
a little bit more complicated than this sample,
certainly have a look at our GitHub repository
and look for the Citrix migration tool.
That's also something that works more or less
into the same space as this.
But let's have a look at this, again, simple script.
So same as before, I log in,
so I'm not going to repeat that part.
Whenever we publish desktops or applications,
we need to know to which system
we're going to publish this resource to.
And you will see that, for example,
if I want to publish a desktop,
there is a commlet called new-rasp-rds-desktop.
And there is also, for application,
there is a new-rasp-rds-app commlet.
So the commlets are different
if you want to publish a desktop or an application
or a local app or some other things.
And the main reason for that is that, of course,
you have different parameters.
In the case of a desktop, for example,
some of you need to know where to publish it from.
So in both examples,
we're going to publish it from the default pool.
But, for example, for a desktop,
we want to specify the desktop size.
And, for example, for an application,
we want to specify which executable it needs to run.
So you will see that the parameters itself
are different based on what you want to publish,
but the principle is the same.
So, for example, in this case,
I'm publishing, as mentioned before, from the default pool.
And because I don't know the pool, I have to get it.
So this is, for example, like a small commlet
to get a list of all the host pools on your system.
And then if you use the parameter minus name default,
it will only show you the default pool.
Then we have the pool,
and then I can use that as an input parameter
for publishing the applications and the desktop.
And then, as I said before,
we should do like an invoke rest apply at the end
to apply the changes.
Same thing, for example,
if you want to know all the parameters for the commlet
for the Rust published desktop,
let me click once more on it,
but you will see that over here,
I have all the commlets and all the details.
So, for example, you will see that
we can publish it from a specific host,
we can publish it from a group,
we can publish it from a server.
So these are all the parameters you can pick.
And as before, everything is explained,
and then you have at the end like an example.
But let's run the script,
and let's show you that it actually works.
So I have over here a Parallels Rust deployment.
As you can see, I only have like one published application,
which is my calculate at this time.
If I go back to my other server,
I have here my little script.
So what I'm going to publish in this case
is something called desktop and something called paint.
Before I do this, I'm all good.
So if I run the script, I log in, everything has gone,
there's no output.
But just to prove you that it has worked,
you see, if I go back to my Parallels environment,
I have my desktop and my paint, which is published.
So this is very simple,
two, three lines of PowerShell code,
and you can publish desktops and applications.
One little enhancement that I have done
onto this basic script is something
which is used very often
in combination with applications and desktops,
and that's the filtering.
So for example, if you go to my paint application,
and you take a look,
then you will see that there is like no filters
except like the default one,
and the default one says for the moment that it's allowed,
if no other rule matches, but there is no other rule.
So in this case, the filter is on.
What I have done as a second example
is I created a small enhancement to the script.
So let's go back to my PowerPoint presentation.
And what I have done is I've added a filter,
and so I've created actually a second script
because I would like to run them independently,
but my second script starts
with finding my paint application,
as you can see over here.
So getRustPublishedUps minus name paint,
so that will look up my paint application.
And what I would like to do is I would like
to add a rule to that paint application.
So this is what I'm doing here.
So I would like to add a rule to what?
To application ID, the number,
which is the one from paint.
The type that I would like to add
is a rule for a published item,
and I want to call this rule a statement.
So this is the first step I'm doing,
just creating like an empty extra rule.
And then in that rule, as you know,
we can put like multiple criteria.
So what I will do is to that rule,
I'm going to add a first criteria,
and that first criteria will be based on security principle.
So basically what I want to do is like,
I want to filter based on a specific group.
So I'm going to enable that one.
And then the second rule that I would like to add
is I would like to also add a filter based on IP addresses.
So what this line will basically do
is it will, where this one will just create the rule statement.
This one will create a first criteria
where I will be able to filter on users or groups,
and where I'll be able to filter on IPs.
And then the rest of the script
will actually fill in the parameters.
So what I will do is I'm going to add
a security principle criteria.
And so on what, on that application,
on that published item object,
which rule, the first rule.
And so this is a little bit like where it's very clear
that I'm not a developer.
I'm just assuming this is empty
and I'm just taking like the first criteria.
So that's what I'm doing here.
Like criteria no ID, criteria no ID,
which will give me basically the ID of this rule.
And what I'm going to do is I'm going to specify
that the guests account is allowed.
And I'm going to do the same thing for IPs.
I'm just going to add a range.
So I'm going to say that for this application,
you need to be somewhere in the range
from 10.0.0.1 to 10.0.0.12.
So these are the parameters that I'm going to set.
So these two lines will actually change this to that part.
And then there's like one last thing we need to do,
and that's change the default rule.
So remember that the default rule says
like if nothing applies, then it's okay.
What we need to do is like change the default behavior
from accept to deny.
So this is what I'm doing here.
So for that same rule that I've added,
so the rule that I'm adding here,
what I'm doing is I'm changing the default behavior
to deny and then to make everything active,
I have to do the RAS apply again.
And of course, so if I want to show you that in real life,
so as you remember before, the filters are empty.
Something important to mention is
if I would run the script like this and I can actually,
I'm not going to do it right now,
but if I would run the script like this,
I will get an error because this object
is currently logged by the console.
So before I run the script,
I'm just going to select something else.
But if I go back here and I go to the second script,
which is exactly what we just discussed,
if I run this, it's finished.
If I go back and I go to paint,
what you will see is that the staving rule is there.
And then you can see that it's like a criteria added,
which is like, it's only allowed for the group guests,
as you can see here, guests,
and it's only for IPs from one to 12.
So also this part of the publishing,
you can fully automate.
It's a little bit more steps you need to do.
First the rule, then you need to add
which criteria apply to this rule.
Then you have to, you should not forget
to change the default rule,
but basically everything can be configured.
So you could, for example, do the same thing
for a routing script or a shortcut script.
So all these parameters can all be updated automatically
from in this.
But I just want to show you is like,
I'm having the object open now, let's say.
I would run the script like a third, another time.
You see, I get like a bunch of errors this time.
And you see that the main reason is that the,
you see it over here, for example,
properties cannot be opened.
The published item property are locked
by staving from the session.
And so just be aware that if you're like developing
these scripts and you're writing them,
that there's still the same rules apply
that some objects could be locked by the console.
And it's also locked for the API.
So you need to remember that you have to,
that you have to move it to not the object
to make this script run.
But this is like a very simple script
to on one hand, publish applications and desktops.
And then second script is to, for example,
add the filtering.
And let me switch back to my slides.
So we've discussed these basic scripts.
For those of you who have ever followed
like a classroom training with me
or with one of my colleagues,
you will probably see that we provide
to all the participants like a known test machine
to play with during the classroom trainings.
All these machines are, of course,
also not things that we do manually.
Also, all of that is automated.
So for example, when we use classroom trainings
and we need like 15 or 20 or 25 lab servers,
we use also some PowerShell scripts to automate that.
So this is a small extract from one of my scripts
that I used to prepare these labs.
And this is a completely other topic,
but this is, for example, how to generate,
let's encrypt certificates through the API.
So even these more complicated things can be automated.
This is, for example, some code
that I copied out of the script.
So once I'm logged into my machine,
so this is always the same part.
The first time you want to use, for example,
let's encrypt, and you will notice that
if you do that through the console.
So the first time you want to use let's encrypt,
you have to accept with the end user license agreement
from let's encrypt.
So that's like a check mark you have to do.
So it's exactly the same story.
So let's say you have like a brand new
Parallels deployment and you want to activate a script.
So the first thing you will actually have to do
is also accept the terms.
So even for that, there is a PowerShell comment.
So the PowerShell comment is called
set trust, let's encrypt settings.
Site ID, that's the site,
and because the certificates are per site,
so let's assume you have like two sites in your environment,
then you have to accept them for the first site,
you have to accept them for the second site.
So in this case, I'm going for site one
and I put them two, two, two.
So basically that will just put the check mark.
And then the second one is that we can pull
a new certificate.
So there is a comment which is called new last certificate.
And then there is a parameter which is called
minus let's encrypt.
So that specifies that we want to generate
the let's encrypt certificate.
And then for the rest, it's the same.
So we're going to specify
that what's the name of the certificate?
What's the common name?
And so that will be then, for example,
lab.mypublicdomain.com.
The email address where the let's encrypt renewals
needs to be sent to.
Enable through it, just to make sure it's active,
the organization details, the key size.
And then this one, usage,
this is the same as you can see here.
So we can specify where the certificate
needs to be deployed to.
So in this case, I only want to deploy it,
for example, on the gateway.
Then I keep gateway, and then it will be
on the gateway only.
If you want both, you can do like comma,
I'll be deployed on the HALB also.
And then it has applied to activate it.
So this is a very simple script, again,
like two lines of code,
how to, via the API, generate certificates.
And a last example, also something that I use
in my lab systems is,
and that's like going even like one step further.
And my lab servers that I typically deploy
are actually like a multi-tenant environment.
So for those of you who are not very familiar
with multi-tenant environments,
we have done a webinar on advanced architectures.
One of the advanced architectures that we discussed
was a multi-tenant architecture.
Multi-tenant architecture is actually an architecture
where you have a connection broker,
that's a common layer for the access,
and like all your tenants will go
to that connection broker, tenant broker environment.
And then all your workloads will run
into like isolated, let's call them
customer tenant environments.
And we have customers that have a few hundreds,
even to more than thousand customer environments
that they make available in a multi-tenant environment
behind the tenant broker.
And they want to automate that.
Of course, they not only want to deploy
that tenant fully automatically
and do all the installation,
but they also want to join that tenant
into the tenant broker.
And this is basically like the code
that you're seeing here.
And it's a two-step process.
So one part is the thing that needs to happen
on the tenant broker itself.
So what we need to do on the tenant broker
is we need to prepare the tenant broker
for accepting this customer tenant.
And again, for those of you who have followed
the other webinar or who are familiar with that,
there are two ways you could do that.
You could do that with an invitation hash.
And an invitation hash is basically
that you create up front,
like a sort of like a template
and a unique key that can be used to onboard
like one customer tenant into the environment.
And then you can, for example,
email that to the administrator of that tenant
and he can use that to register his tenant
with your tenant broker.
The other way you could do that is with a secret key.
And that's something I also explained
during that session.
This is the way or the method that I'm using
in this PowerShell script.
So what I'm going to do first is
I'm going to specify that secret key is allowed
because that secret key is very powerful.
That secret key will just register any tenant
that wants to join your connection broker
and that has that secret key.
So there is like no check or no template
that needs to be created.
Like anyone with that key can register his tenant
in your tenant broker.
So that's a security thing that needs to be enabled first.
So by default, it's off.
So this is what you're doing here.
It's set to last tenant broker settings.
So that's a comment.
And then the setting, what we want to change
is the allow registration with secret key to two.
So that's the first step.
So we have to allow that that secret key can be used.
Of course, then we don't have the secret key yet.
So this is something that you also need to know.
How can you create such a secret key?
That's via the invoke raster and broker settings.
And then there's something where you can do
like command generate hash
and that will generate that secret key.
So the secret key will be stored in this variable.
And of course, we have to apply again
on the last apply to make it active.
And then the second part of my code
will get into every of these lab services.
So for example, if I want to have like 25 lab servers,
I will make a loop saying like login to lab server one,
login to lab server two, login to lab server 25.
And once that is done, so this is what you see over here.
So I'm making a new connection
with that specific machine that I want to join.
There is again a comment
which is called invoke raster and broker.
Mine is join.
So to join a tenant broker via a hash key,
which is the secret key that we have generated here.
We need to specify the tenant broker details.
So we want to join that machine.
So the machine is called tbvm.
So that's my tenant broker.
I need to specify the public domain address.
This has to do with how the multi-tenant environment works.
For every multi-tenant that you want to join
in a multi-tenant environment,
you have to specify a public DNS name.
So this is basically what we pass here.
And then we just have to give it a name.
So the tenant name is what we specify here
and then invoke raster apply.
So again, with like two or three lines
of PowerShell commands,
we can activate the multi-tenant site,
the tenant broker site,
and we can join a tenant broker.
We can join a customer tenant into a tenant broker.
So as you can see, it goes pretty far
and it's pretty advanced that you can do
with the PowerShell API.
As I said before, that's part of the PowerShell API for now.
Everything we do on the backend side
with the Parallels console can be automated through API.
PowerShell is one way.
The other way is via the REST API.
To use the REST API,
you need to have the Parallels REST web console running.
So this is something that needs to be set up.
Again, by default, if you do like a next, next, next,
finish install, it will be there.
But it's important that the REST API
run on top of the web console.
So if you want to, let's say,
access this REST API from outside,
you will have to make, for example,
your REST web console also available from outside.
So this is something you have to take into account.
The web console runs on port 2443.
So that's the default web console port.
And everything works based on JSON.
And it's just a standard RESTful API.
So the way it works is, first of all, you have to log in.
So there is an API call that you have to call,
which is the logon API call.
So you have to go to API sessions logon.
What do you need to pass?
You need to pass two things.
First of all, you need to specify that the content
which you're going to send via a post call is JSON format.
And the content itself, the body,
needs to look like this,
like username, double point,
and then your username, comma,
password, double point, your password.
And if that is successful,
what you will get back is an alt token.
So you will get, after a successful login,
you will get back this alt token.
And then for all your next queries through the REST API,
you have to add that alt token into the header.
So you have to extend your header,
put that alt token into your header.
And then once that is done,
you can, for example, call the API sites
or the API gateway or whatever
to start interacting with the REST API.
It's very standard.
It's get, post, put, delete.
So it's a pretty standard way of working.
Everything is JSON formatted.
So it's rather straightforward.
There is also, for the PowerShell API,
there is also a separate manual with all the details.
So if you want to go through it,
for example, if you want to get the list
of all the gateways, you can just go into here
and then click on gateways and get all the details.
So this is also pretty well documented in here.
So it's there.
So you see, it has some samples,
like if you do a get,
this is the response that you get.
If you do a put, if you do a post,
like all the details are in here
based on the different commands.
For example, if you do like API gateway,
it will give you the list of the gateways.
If you want to see like a specific gateway detail,
you have to do like API gateway
and then the number to scroll through it.
So everything is pretty well documented.
If you want to do like an update,
you do a put, if you want to delete one.
So all the details are there.
Just to show you how it works.
And again, I'm not a developer,
so I used PowerShell to mimic the REST API
in this example.
So apologies to all developers who are online,
but this was for me the most easy way
to explain you how the REST API works.
So this is not the PowerShell API
that I'm using with the REST API.
So what I have done in this simple script
is I created a header.
So I created the new one.
I added the application JSON as the type.
I created a JSON object username password.
I converted it to JSON.
And then what I'm going to do
is that I'm going to log into that machine
on the API sessions logon.
And what I'm doing is invoke REST method,
method post, which you and I,
this one in the logon API,
which what I'm going to pass as a body
is the username.
And then I'm using the headers that I have created.
I'm using over here, as you can see,
the skip certificate check.
That is because my certificate
is not trusted on this one.
This was also like a little bit being lazy,
but that's how it works.
And then once it's done, you get the result.
So the result is there.
And then if you look in the result,
there will be an alt token,
which is that unique token for this session.
I'm just adding it to the header.
So alt token added to the header.
And then I can do like all the commands
like API gateways and so on and so on.
So this is, for example,
like an example how you can use also the REST API
to connect to Parallels.
So if you're more into things like Python
or any other programming or scripting language,
then you could use this method
of interacting with the backend APIs.
Good.
Let's go to the second part of the training,
which is the client side.
So, so far we have been automating
and doing all kinds of magic on the backend.
But also on the client side,
there's a lot of automation possible.
One of the first things we could, for example, do
is we could craft a URL and that's the Web Client API.
We could craft a URL that, for example,
starts directly a specific application.
So maybe you want to integrate Parallels
into like another website or into another system.
Then you can craft a Web Client URL.
And the most important part is that app ID.
So if you know the app ID of the application,
you can, for example, say like HTTPS,
your gateway, question mark, app ID equals,
and then the number.
You could also do like override parameters
and some extra parameters that need to be passed on.
But basically, if you know the app ID,
you can very easily start it.
And you can specify the team if needed.
You can combine everything.
And so you can also say like user portal equals team.
So it's pretty, pretty powerful.
If you want to know all the details,
again, if you go to docs.parallels.com,
there is also for, this is not a separate manual,
but this is part of the administrator's guide.
But if you go into the administrator's guide,
you will see that there is also like a full chapter
explaining you all the parameters and all the IDs.
So how does it work in reality?
So I have over here my calculator.
And as you can see, my calculator has a number 26.
So this is something you can see here,
information, application.
So in my case, my calculator is number 26.
So what I have done here is I've, let me just show it.
I've just crafted a URL, which is like my gateway,
and then app ID equals 26.
So if I do this, what will happen is I will,
start RAS.
It will prompt me for my username and my password.
My password, hopefully.
Yeah, and then as you can see,
it automatically starts the application,
and it's there, my calculator is established.
This is the most simple case here.
Let's quickly go back to the slides
before I show you the second example.
So in this case, I still have to provide my username
and password.
For some users, this will be fine.
But if you want to do, for example, a deeper integration,
or maybe you're an ISV and you want to combine
some of the stuff you have on your web portal
with some of the stuff which we publish through Parallels,
this Web Client API becomes much more powerful
because what you can also do
is you can also pass a JSON file to it.
And that JSON file can, for example,
contain things like certain client settings.
So you could, for example, specify a username,
you could specify even a password,
you could specify if audio needs to be redirected,
which client settings need to be done.
So it is possible, for example,
to do a full single sign-on from a published web link
all the way into an application that actually runs.
So the typical use case would be like, for example,
you want to integrate this resource
in a completely different user portal.
The way it works is like this.
So you craft a URL, and then what you need to do
is you need to specify a JSON file
containing a specific structure.
So again, if you want to know more,
there is a document that describes it,
so let me open it for you and show it.
But if you craft a JSON file that looks like this,
where you say username, password,
and then the A stands for which application
that you want to run, so the number,
and then you can specify a bunch of other parameters.
The other parameters are optional,
but you could specify override parameters,
logon URL, logoff URL, so all these details.
Everything is described in this setting.
You could do a full single sign-on.
So this is actually what I have done.
So I have here crafted a JSON file.
I've just put it on a dummy web server.
This is also something that I discovered the hard way
while preparing for this webinar.
If you craft these files,
they need to run on HTTPS with a trusted certificate.
So if you run it on an HTTP website,
it will not work from a security point of view.
But what you can do then is if you take a look here
at this URL, so let me show you.
So it's the same as before.
So it's my internal machine user portal question mark.
And then I'm just specifying that JSON file
that I have crafted.
And then this is just something you see that
and it's a hash slash launch.
And that will actually launch the app directly.
So where if I started this one calculator,
I had to type it in.
If I launched this one, it will fetch the settings
from that website.
And then you will see it doesn't,
it will not prompt me for username and password.
It will just log in and give you my favorite calculator.
So you see that that web API is pretty powerful
and can be integrated.
Of course, you would not do it this way.
You would create it, for example,
with a unique identifier and you would delete it afterwards.
But there are ways if you're like an ISV
that you could, for example,
integrate your own application
with some published applications from Viyara.
So that's the main lesson I want to give you with this
is that there are ways to pass data from one system
to another that would be needed.
So this is all for the web client.
We can do the same with the native clients.
So if you would use not the web client,
but the native clients,
you will see that there is a specific URL
handle per native client.
It's either PLS client or fixed client,
but there is a URL handler.
And via that URL handler,
you can also pass or query certain information.
So for example, you can, for example,
use it to change settings on the client,
or you can use it to open a session,
or you can use it to log off a session.
So you can do the same things with the native clients,
like demonstrate with web client
also via the native clients.
The URL scheme looks a little bit different.
So there is also a way that you could,
there are things like get version
and launch up and get to XA.
So there is a bunch of things that would work.
That get to XA setting is more or less the same
as the JSON from before.
The only thing you will notice
is that the file that you need to craft is a bit different.
So if you go to the documentation,
you will see that it's a little bit different.
And then this is some options.
Let me go to it.
This is the get version.
This is what I was looking for.
So you can specify like also a file
and then either via a comment line.
So this is the comment line.
And then you can also do it via an HTML file.
You can craft it.
And then you see it looks a little bit different.
It has a little bit different.
It's not really JSON.
It's more like a sort of a structured file.
But if you create these kinds of files,
you can do the same thing with the native client
and use the native clients also automatically
through RAS.
The last thing before I jump into the questions
is something that probably none of you
will have ever heard because it's in the product,
but I don't think we have ever
did any communication on it.
So since we have modernized our Windows client,
the Windows client can also work in CLI mode,
so in interactive mode.
And actually it's on your system.
So if you're running like one of the more recent versions
of Parallels, you will see that you can also automate
and script things through the Windows client CLI.
And let me just give you a quick example.
So I'm here on my own machine right now.
So I'm into my installed Parallels client directly.
So you see I'm in program files, Parallels client,
modern UI.
And then in here, there is the app server client CLI
that I can start.
So it's just an executable device.
If I start it, it's there.
It has a lot of documentation, so if you click help,
it will show you everything which is possible.
So there's a bunch of things we can do,
like I'm saying something like add connection,
list connections, like all this stuff you can do.
Like for example, if I would do list connections,
it will show you my connections that I have in my system.
So you see, it will show you my connections.
I actually, I don't want to update right now,
but you will see, it will show you my connections.
It will show you how to connect and so on and so on.
What I could do, for example, like now,
I could say like log on, log on Russ.
So that will just take my default one,
which is in my case, the first one.
Otherwise, I can also do things like minus ID
and specify log on Russ.
So you see, it will automatically now start my client.
I'm connected.
It will show me all the applications
which are available to me.
So for example, you see, I have Word Publisher,
so I have a bunch of applications.
And let me start my favorite one.
So if I do like start Russ objects minus ID
and Russ 161171, which is my calculator app,
you will see, I got the result.
Okay, so that means that it's working
and my client is now connecting
and it should present like in a few seconds,
normally calculate.
Yeah, there it is.
So I have my published calculator running.
So this is also like another way
that we can interact or automate stuff through Parallel.
So this could be, for example, like a very nice way
if you want to do like some end-to-end monitoring.
Let's say you want to do like some performance monitoring
or client monitoring.
This is like a very nice way you could all the way
automate the client monitoring through a remote client.
Yeah, so it's not this one.
So I was at this last slide.
Maybe also like a last remark on that CLI.
Everything is again, adjacent.
So you could even use that into PowerShell, for example,
to automate things on the client side.
So you can just also pass all the commands
and all the parameters as an argument
to the executable and then it returns
always adjacent so you can also very easily automate
that to PowerShell.
So the client side can also be automated
through PowerShell via the Windows Client CLI.
So this brings me to the,
so this is the example that I've given you.
Of course, if you want to log off,
there's a command called log off for us.
That's something I didn't do, but that's the last thing
I wanted to show you today.
So let me first of all, check if there are any questions.
If there would be any questions,
more than happy to answer them.
I'm checking with Paul.
Okay, Paul has already published the GitHub link.
I see, so that's nice.
And then there are some questions on,
can we have access to the old webinars?
Yes, so the old webinars are all on YouTube.
If you go to the Parallels YouTube channel,
you can find them back.
If you would not find them,
I've shared to you my contact details.
Just drop me an email.
I'm more than happy to send them also over the links
if you would not find them.
Let me just summarize the questions.
So there are some questions like,
the scheduled script runs multiple times within a minute
and causes a lot of sessions in the RAS admin.
So I think this is also something important.
If you make a script,
yeah, you have to think a little bit about it.
Like if you make a script that says like open session,
do this, open session, do this, open session, do that,
then of course you will have like a lot of sessions open.
So it's probably like sometimes better to make a script
like open session, do all the actions
and then close the session.
That will avoid that you have like too many open sessions.
But that's probably like a little bit of like help
that needs to be done on the PowerShell side.
Yeah, there's a question on can we use sessions?
I think, but I'm not sure,
but there is like a sort of like expiration.
So you can keep a session open for a certain amount of time,
but after a certain time,
the session will be closed anyway.
So it's not something that you can keep open
for days.
So there's a, I'm trying to go through all the questions.
There's a few at the start around
kind of encrypting the password
rather than having it in plain text within the script.
I posted a couple of options around there.
Generally, that's kind of how PowerShell tends to work,
but you can use the DP API.
Okay, a cryptic file using that method.
We're going to pull those passwords out of there.
So there are options around that.
Yeah, absolutely.
The first thing I'm going to do after the webinar
is change the password on that user.
But yes, I said again in the beginning,
I'm not a developer.
I also try to keep it pretty simple and straightforward,
but there are indeed some best practices you can do
to not store passwords in scripts.
And I agree in general,
that's certainly a good best practice
to do it that way.
Yeah, I'm looking.
Anything else, Paul, we need to pick up
because I see there are more coming in as we speak.
There was just a few around the same kind of topic
around, you know, can we single sign on
or so I don't want to save the password
in clear text type of thing.
Yeah, yeah.
Oh, good.
With that said, let's call it a day.
I'm going through after the webinar
through the questions.
If I might have forgotten something,
I will contact you individually.
But with that said,
thank you for being present with so many.
Look forward for new sessions.
We're going to announce them pretty soon.
And also look forward.
There will also be some announcement pretty soon
on an updated RAS version
also in the next week's direction.
For those of you, it's your end of day.
Enjoy your evening.
For people joining on the east side of me
from US typically or LATAM,
have a nice day.
For people out of APAC,
I've seen also some people joining from very far away.
Enjoy your night even.
So thank you and speak to you pretty soon hopefully.
Bye-bye.