1c what are routine tasks. Routine and background tasks

The question we put in the title of the article is relevant for many system administrators working with this product. As far as possible, we try to talk about the parameters that affect 1C performance and debunk popular myths. Today, using the example of one recent case, we want to tell you about another aspect that can seriously affect productivity - routine tasks.

Let's start with real case. Not long ago, one of our clients contacted us with a complaint about the 1C “brakes” of one of his employees. The symptoms were that after a certain period of time the Trade Management 10 configuration began to slow down greatly, or, more simply, froze for some time.

With more detailed analysis situation, it turned out that this only happens to one employee, and at any workplace, it has been happening for a long time, but if earlier the “brakes” lasted about a second, now, after the update, they can last up to 15-20 seconds, which makes the work extremely uncomfortable .

In principle, the initial data is already sufficient to draw the first conclusions. Let's list them again:

“Brakes” occur constantly, with a certain frequency
Only slows down for one user
"Slows down" at any workplace

To confirm our guesses, let's look at Accounting settings settings:

Indeed, the “problem” user is listed as a user for performing routine tasks. As it turned out, once upon a time a RIB auto-exchange task was running on behalf of this user. It remains to be seen what exactly was the cause of the episodic “braking”. This is also easy to do:

And here is the “hero of the occasion” - the task of updating the full-text search index, which was launched once every 2.5 minutes. In this case, the problem was completely solved by disabling the execution of routine tasks under this user, however, this is not always possible or advisable, so below we will look at how you can manage routine tasks and how to make sure that they do not affect negative influence for performance.

Regular application

In configurations based on a regular application, there is no single tool for managing routine tasks. This is largely due to the fact that at the time of their initial development the concept of routine tasks itself was rather poorly developed.

Many routine tasks are managed through setting up the subsystems associated with them. For example, the settings for regulatory tasks related to data exchange should be looked for in the exchange settings associated with the Unified State Automated Information System in the alcohol trading settings, etc.

At first glance, everything is quite logical, but the lack of a single tool makes it difficult to control the configured routine tasks and the optimality of their settings. It’s good if there are one or two tasks, but if there are more of them or, as in our case, there is a suspicion of one of the scheduled tasks, but you have no idea who configured what in this database.

In this case, you should use external processing ConsoleTasks (JobsConsole), which is included in the set of standard processing on the ITS disk. Processing provides a single interface for all jobs and allows them to be centrally configured, as well as control the jobs currently running.

This list need to be carefully studied, all unnecessary tasks should be disabled, and those that are needed should have their schedule adjusted to meet immediate needs and common sense. For example, in our case, there is no need to process EGAIS responses once every 30 seconds (this setting was made for testing) and in operating mode it will be quite enough to do this, say, once every half hour.

Managed Application

In configurations based on a managed application, routine tasks are assigned a more significant role; with their help, various tasks can be performed to maintain the information base and keep it up to date, but at the same time, it is routine tasks that most often become the cause of “brakes.”

There is a separate item in the menu to manage routine tasks Administration - Support and Maintenance.

It can be immediately noted that the number of tasks has increased significantly (for example, we took the same configuration - Retail) and their proper configuration can significantly improve the performance of the information base. The default settings are made by 1C based on the needs of an average spherical company in a vacuum and are not even close to optimal.

First of all, we disable what is clearly unnecessary, what you do not work with. Then we optimize the schedule of rarely used functions, for example, updating the bank classifier in Retail, as well as checking counterparties, can be carried out once a week during non-working hours or at the end (beginning) of the working day.

Special attention should be paid to everything related to the search index. Full-text search is certainly a convenient thing, but working with its index is a very, very resource-intensive task. Therefore, you should not go to the extreme and abandon it, but you should seriously reconsider and adjust its parameters.

Let's start with text extraction, this operation allows you to search the contents of attached files, so if you do not use them, do not search through them, or you only have images there, then this operation can be disabled; in any case, performing it once every 85 seconds is clearly overkill.

Update PPD index - one of the most resource-intensive operations, performed once per minute by default.

Now let’s think about how often the information that you most often search for is added or updated in the database? Obviously not every minute, so it will be quite enough to update the index much less frequently: once an hour, once a day, or even once a week.

The same applies to merger of the PPD index If you update the index once a day, you should configure the merge to run once a week, choosing the least disruptive time to start the job.

These simple operations will allow you to increase the comfort of working with it without much damage to the functionality of the configuration. new level by eliminating the frequent execution of fairly resource-intensive operations. Just don’t go to extremes; judge wisely how much you need certain capabilities and how often you should perform tasks related to them.

Tags:

Please enable JavaScript to view the

" In it we will look at new features that do not relate to the system interface, but significantly expand the provided functionality of the 1C:Enterprise 8 platform.

Applicability

The article discusses the 1C:Enterprise platform version 8.3.4.437. All functionality described in the article has been updated to version 8.3.11.

Other innovations in 1C:Enterprise 8.3

Let's continue to get acquainted with the innovations of the 1C:Enterprise 8.3 platform.

Background and routine tasks in the file infobase

In many typical platform configurations 8.2 there was a constant that indicated the user under whom the tasks were executed in the file version.

When the system started running under this user, a wait handler was connected, which called the built-in language method with a certain periodicity ExecuteTaskProcessing().

This approach created additional difficulties and inconveniences for using routine tasks in the file database.

This could be especially critical when working with configurations such as “Comprehensive automation” or "Control manufacturing enterprise” , in which regulatory tasks play a rather important role.

If This Is File IB Then
=
Constants.UserForExecutingRoutineTasksInFileVariant.Get();
If chValueVariable(“glCurrentUser”) =
UserTo ExecuteTaskRegl Then
// with an interval of seconds we call the procedure for working with routine tasks
SupportRegularTaskForFileVersion();
IntervalForPoll=
Constants.IntervalForPollingRoutineTasksInFileVariant.Get();
If IntervalForPoll= Undefined
OR IntervalForPoll= 0 Then
IntervalForPoll= 60 ;
EndIf ;
ConnectWaitHandler(“Support for RoutineTaskForFileVersion”,
IntervalForPoll);
EndIf ;
EndIf ;

On the platform 8.3 implemented the work of background and routine jobs in the file infobase without using the global context method call ExecuteTaskProcessing().

Background and routine tasks are performed directly in one of the client applications (thin, thick client) or by a web server extension.

A background job started by a session is executed by the same client application that initiated it.

Background jobs are executed sequentially, i.e. On one client application, only one background task (including routine ones) can be executed at one time.

Routine tasks are performed by only one client application. To control the launch of scheduled tasks, a command line key is used /AllowExecuteScheduledJobs.

Routine tasks are executed by the first client application in the startup order, which is not prohibited from executing routine tasks (to prohibit the session, the session must be launched with the command line parameter /AllowExecuteScheduledJobs -Off).

When that session ends, execution moves to any of the remaining running sessions.

If the launch line of the client application explicitly indicates the need to run routine tasks (in command line indicated /AllowExecuteScheduledJobs -Force), then routine tasks begin to be executed on it, regardless of the presence of other sessions.

Routine tasks are processed once every 60 seconds.

Note that the routine tasks of the application solution (in the file version) began to be executed no earlier than 1 minute after the client application was launched. Starting with version 8.3.8, this time has been doubled, and therefore routine tasks begin to be executed a maximum of 2 minutes after the client is launched (in the file version).

This decision is due to a reduction in the delay when starting the application. In addition, in release 8.3.7 the ability was added quick definition that the current session is a background job session. This is implemented using the new global context method GetCurrentInfoBaseSession(), as well as a new method for the infobase session GetBackgroundTask().

Below is code that illustrates the above:

To enlarge, click on the image.

Calculation of checksums

The platform now includes mechanisms for calculating data checksums.

Let us recall that checksum(hash) is a value calculated from a set of data by applying a certain algorithm and used to check the integrity of data during transmission or storage.

Hashes can be used to check the identity of data (for example, you need to make sure that when transferring a file it was not damaged; check whether changes were made to the file, and if so, then upload it to the database again).

For this purpose, an object was implemented in the platform HashingData, available on the server, in the thick client, external connection, and also on the mobile application server.

This object has two methods: Add() And AddFile(), which update the hash sum taking into account the data passed in the parameters.

Platform 8.3.4.437 supports calculation of the following hash functions: CRC32, MD5, SHA1, SHA256. But the functions SHA1 And SHA256 are not supported on the mobile platform.

Let's look at a simple example. It is assumed that on the server in the program directory there is a file “ ragent.exe" Need to calculate MD5-sum for this file.

To do this, we will create an external processing, on the form of which we will place the command Calculate. The handler contains the following code:

&OnClient
Procedure Calculate (Command)
Result = CalculateOnServer();
Report(String(Result));
End of Procedure
&OnServer
Function CalculateOnServer()
Hash = New HashingData(HashFunction.MD5);
Hash.AddFile(CatalogPrograms() + “ragent.exe” );
Return Hash.HashSum ;
EndFunction

In edition platform 8.3.10+ in the method Add() object HashingData It became possible to use a stream of binary data, which greatly simplified their use in solving various applied problems of updating hash sums.

Working with protected versions of protocols SMTP/POP3

On the platform 8.3 it became possible to use protected versions of protocols SMTP/POP3(there are terms SMTPS/POP3S or SSLSMTP/SSLPOP3).

For object InternetMailProfile new properties implemented:

Use SSLSMTP;
UseSSLPOP3;
Only SecureAuthenticationSMTP;
POP3 Secure Authentication Only.

Properties SMTP Authentication And POP3 authentication object InternetMailProfile, as well as transfers SMTPAuthentication method And POP3 Authentication Method It is not recommended to use them - they are supported for compatibility.

Using a secure protocol SMTPS makes it possible to send mail from 1C, using by mailbox Google.

Let's look at an example. On the form we will place fields for entering the subject of the letter and the recipient's address, and for entering the text of the letter - a formatted document field.

To enlarge, click on the image.

When you press the button Send The following code will be executed:

&OnClient
Procedure Send (Command) Mail = New InternetMail; Profile = New InternetMailProfile;
Profile.SMTPServerAddress= “smtp.googlemail.com” ;
Profile.UserSMTP= “[email protected]” ;
Profile.PasswordSMTP= “PASSWORD” ;
Profile.UseSSLSMTP= True ;
Profile.SMTPPort = 465 ; Attempt
Mail.Connect(Profile);
Exception
Report(ErrorDescription());
Return ;
EndAttempt ; MailMessageText= “” ;
Attachments = New Structure ;
Text.GetHTML(MailMessageText, Attachments); MailMessage= New InternetMailMessage;
MailMessage.Recipients.Add(To whom );
MailMessage.Subject= Subject;
MailMessage.Texts.Add(MailMessageText,
MailMessageTextType.HTML); Mail.Send ( MailMessage); Mail.Disconnect();
End of Procedure

Note that in our example, if the SMTP server was unable to send an email to the recipient(s), then the method Mail.Send(MailMessage) threw an exception. This caused certain inconvenience for the developers, because... The reason for throwing the exception was not obvious.

In version 8.3.9, this behavior has changed, and now the Send() method returns a match whose key is the recipient and whose value is the diagnostic from the mail server. This allows you to accurately determine the reasons for the failure to send an email message to each recipient. In compatibility mode with version 8.3.8, the behavior has not changed.

Duplex printing

On the platform 8.2 The platform itself did not manage duplex printing; this function could only be controlled using the printer driver.

On the platform 8.3 it became possible to control duplex printing for a spreadsheet document, a graphic diagram (from the built-in language and interactively) and a text document (interactive only).

System enumerations appeared in the built-in language:

Duplex Printing Type(None, FlipUp, FlipLeft);
(Auto, MirrorTop, MirrorLeft, Do Not Use).

And for objects TabularDocument And GraphicScheme properties appeared Duplex Printing And Alternation of Page Arrangements, with which you can change the layout of printed pages.

In platform version 8.3.9, the DuplexPrintType system enumeration has a new value added UsePrinterSettings. Selecting this value allowed you to use the printer settings when printing system documents. In 8.3.8 compatibility mode, the behavior is unchanged and the corresponding printer settings are ignored.

The dialog for publishing an information base on a web server has been made more functional. Now publishing from the configurator allows you to set all file parameters default.vrd.

For the dialog for publishing a web client and Web services through the configurator, the following is implemented:

ability to control the availability of Web services by default (attribute pointEnableCommon element ws);
ability to control the execution of background jobs in the file version (attribute allowexecutescheduledjobs element ws).

If checkbox “Publish Web Services by Default” on the bookmark “Basic” is installed, then when updating the publication, the selected Web services will be published automatically.

Otherwise, the Web services will be marked as unpublishable. This flag corresponds to the attribute pointEnableCommon element ws in the file default.vrd, intended for setting up a web client and Web services.

Attribute pointEnableCommon ws element is responsible for the possibility of using in this information base Web services that are published without explicitly indicating permission for use (attribute enable element point).

If the attribute has a value true, then all Web services for which the attribute value is not explicitly specified enable element point, will be allowed for use.

Otherwise, the use of such Web services will be prohibited.

Settings “Background jobs in file mode” matches attribute allowexecutescheduledjobs ws element in the file default.vrd.

Attribute allowexecutescheduledjobs controls the ability to execute routine tasks by the web server extension for the file version of the infobase.

The attribute can take the following values:

off– in this case, the web server extension will not perform routine tasks. Routine tasks will be performed by a client application (if one exists), which connects to the infobase directly, without using a web server.
force– in this case, the web server extension will perform routine tasks.
If the value of this attribute is not specified, then routine tasks will be performed by the application that will be used to make the first connection to the infobase.

The publishing window on the web service has become even more convenient and ergonomic in the current release of the platform. Now the parameters describing OpenID authentication are placed on a separate tab.

Numbering of infobase objects

On the platform 8.3 The mechanism for automatically numbering information base objects has been reworked. The uniqueness of a number or code (including those obtained as a result of automatic generation of a number or code) is always checked when recording an object.

An indication of which number or code is not unique has been added to the text of the message about violation of the uniqueness of a number or code.

The use of a vacant number or code has changed. New number or the code is assigned without using released numbers or codes, if there are already issued numbers or codes with a large (in order) prefix of the number or code.

Aggregate functions of the data composition system expression language

New aggregate functions are implemented in the expression language of the data composition system:

Every();
Any();
StandardDeviationofPopulation();
StandardSampleDeviation();
VarianceSamples();
VarianceofPopulation();
CovariancePopulation();
SampleCovariance();
Correlation();
RegressionSlope();
RegressionSegment();
RegressionCount();
RegressionR2();
RegressionAverageX();
RegressionAverageY();
RegressionAverageSXX();
RegressionAverageSYY();
RegressionAverageSXY().

As the names indicate, these are statistical functions, which means that developers have the opportunity to create complex reports without having to develop procedures for calculating statistical data.

To enlarge, click on the image.

As you can see from the figure, there are no new functions in the drop-down list, but if you enter them manually, there will be no error message, and the report will be generated:

Also of interest new featureClassificationABC(). The result of the function will be the class number, starting from 1 (1 corresponds to class A, 2 to class B, 3 to class C, etc.).

Let's demonstrate how this function works. Let's create a new external report “Classification of goods” based on request:

CHOOSE
Product consumptionProducts.Product,
Product ConsumptionProducts.Quantity
FROM
Document.Consumption of Goods.Goods HOW Product consumptionProducts

Let's define a new calculated field Class:

To enlarge, click on the image.

Let's configure the resources as follows:

To enlarge, click on the image.

In user mode, the report looks like this:

In conclusion, we note that from edition to edition in the 1C 8.3 platform the ACS mechanism is constantly being improved and refined, and within the framework of our “newbie” article it is not possible to present these changes in full. Yes, this seems unnecessary, because when working on the current version of the platform, you can always use various help systems to help you analyze this or that aspect of the operation of this mechanism.

In addition, do not forget about our separate course Professional development of reports in 1C 8.3 on the Data Composition System, which breaks down down to the atom all the subtleties and pitfalls when working with this mechanism. Check out the demo for yourself.

So, let's sum up the intermediate results. Up to this point, we have become acquainted with the new capabilities of the Taxi interface and managed forms, as well as with some previously not provided capabilities of the platform itself. Now it’s time to see what convenient features have become available to the developer in the configurator.

Allows us to perform any calculations in the system unnoticed by the user, that is, in the background. Moreover, this mechanism allows us to parallelize the calculation process. We can even parallelize the procedure that will be executed. To do this, our background job must run several more background jobs. In this case, the processes are parallelized and, if we have a multiprocessor, multi-core system, our algorithm will work efficiently. After launching several processes, we can tell the system that it needs to wait for the completion of these processes in order to somehow combine the result.

For example, in typical configurations, while the user is working, the various kinds service background jobs. This can be evidenced by log entries that record the fact that such actions were performed. Moreover, this does not affect the user’s work in any way, he simply does not notice them.

Ideally, a background job is implemented in a client-server version, in which case the entire load goes to the server. As for the file version, a background job is possible, but it has some peculiarities.

This is what the system will produce if you do not take these features into account and run a background job in the file version of the infobase.

The 1C background job has some limitations. Since it runs on the server side, there is no possibility of interactive work with the user. For example, you cannot display a message, or any information at all. All this data needs to be stored within the information base and further processed in some way.

By contacting the syntax assistant, you can get more detailed information about 1C background jobs. It should be noted here that this object is purely software and is not stored in the database in any way. That is, we create an instance of the class, initialize the properties and launch it for execution.

What tools do we have to manage background jobs? This facility is a metadata object "BackgroundTask Manager". This object has a method "Run", using this method, the background job is launched.

It has the following parameters:
"MethodName"- the name of the procedure or function to be executed, and it must be a procedure or function of the server context;

"Options"- an array of parameters, the number of elements of which must correspond to the number of parameters of our procedure/function specified in the parameter "MethodName";

"Key"- a certain uniqueness key, which is a line by which the system understands whether a background task needs to be launched or whether such a task is already running;

"Name"- here you can specify an arbitrary description of our method.

The return value is an object "BackgroundTask", containing the current method name, the current key, and several more properties and methods. One such method is the method "WaitComplete". Its purpose is that we can tell the system not to do anything until the background job is completed.

Background job 1C 8.2, 8.3 - Example of use

Let's give an example of working with 1C background jobs. First, we will create a simple algorithm that will briefly load the 1C system in such a way that we cannot do anything at this time.

To do this:

1. Let's create a common module "BackgroundTask Handlers", which will be compiled on the server side;

2. We will describe the export procedure in it "ProduceBackgroundCalculation(Parameter)", which takes one parameter of string type;

Procedure PerformBackgroundCalculation(Parameter) ExportStartTime = CurrentDate() ; While CurrentDate() - Start Time< = 6 Цикл КонецЦикла ; КонецПроцедуры Процедура КнНажатие() ОбработчикиФоновыхЗаданий. ПроизветиФоновоеВычисление("Some parameter") ; End of Procedure

Ready. Now, when you start processing and press a button, the system freezes for several seconds, during which nothing can be done. This is exactly what we needed to do.

Now we will ensure that these calculations are carried out in the background, that is, so that the background task 1C 8.2, 8.3 is executed, but does not interfere with us.

To do this:

1. In processing, in the button click event, write the following code.

Procedure KnPress() Parameters = New Array; Options. Add( "Some parameter") ; BackgroundTask. Run ( "BackgroundTask Handlers. Perform BackgroundComputation", Parameters, New UniqueIdentifier, "Test task") ; End of Procedure

Here we pass the name of the common module procedure as the first parameter, and an array of parameters as the second. The third parameter needs to be passed a unique key and the fourth parameter some description of our procedure.

Often, when maintaining records, there is a need to periodically perform certain actions without user intervention. Routine and background tasks in 1C are those mechanisms that are provided for this purpose in the eighth version of the program and allow:

Set up timely delivery of documents;
Calculate balances and totals;
Provide frequency mailing list;
Check and delete irrelevant data.

Background and scheduled task - what is it and where is it configured?

Scheduled task- a mechanism built into 1C that allows you to configure and, in accordance with the established schedule and frequency, perform a certain sequence of actions.

A background job is an action generated by a routine operation and does not require direct user participation.

A routine task is created in the configurator mode:

In the configuration tree window we find the corresponding branch (Fig. 1);

Click the add button;
In the window that opens, you must specify a name that allows you to identify the object in the configuration;

Fig.2

Opposite the inscription “Schedule” (Fig. 2) there is an inscription “Open”, clicking on which opens a window for setting the time and frequency of execution of the handler (Fig. 3);

Fig.3

It is also necessary to fill in the “Method name” (the name of the procedure called from the general module and describing the behavior algorithm of the program will be entered here);
The “Name” and “Key” fields allow you to group objects;
The checked “Use” checkbox indicates the activity of the scheduled operation;
“Predefined” should be set if the handler should be launched immediately after it is added to the database, otherwise the launch can be done from the corresponding processing (more about it below);
The “Number of retries” and “Retry interval” parameters describe the program’s behavior if an exception occurs while executing a background job.

So, using the mechanism of routine operations, you can set the schedule and main actions of background jobs. Let's now look at their features.

Features of background jobs

The main feature of this mechanism is that the background process runs asynchronously.

What does this mean? The fact is that with a synchronous work model, if any algorithm is executed, the user interface is blocked. In our case, the user can continue to enter and edit data even if the procedure is running. The asynchronous programming model involves separation of computational threads.

Thus, background jobs in 1C can spawn their own processes, distributing calculations across various servers included in the same cluster.

Features of working in client-server mode

Execution planning and control is carried out by a scheduler from a server cluster;
If a request for execution appears, the scheduler looks for cluster worker processes with minimal load and distributes tasks to them for execution;
Each process can perform multiple parallel computations;
After a task arrives, the process connects to the database and executes the algorithm in it;
The process reports the results to the scheduler.

Background jobs in file mode

Before platform version 8.3.3.641, working with background jobs in the file version presented some difficulties:

It was necessary to launch a separate session that would work around the clock, replacing the scheduler;
This session should have periodically executed the RunJobProcessing() method.

After the update, each start of the thick and thin clients, if the AllowExecuteScheduledJobs key is specified in the launch settings (Fig. 4) in the “Additional” field, initiates an additional thread for connecting to the database, which does not affect the user’s work in any way, but only performs background work. operations.

Fig.4

It should be taken into account that even in the file version of work, background processes do not allow interactive work with the user (service messages, warnings, and questions will not be displayed). That is, they must be coded as if they would be executed on the server side.

How to disable scheduled tasks

Unused tasks can be disabled by simply unchecking the “Use” checkbox in the object properties.

In the case when the administrator needs to prohibit the use of routine and background operations for the entire database as a whole (for example, several databases are stored on the server, of which only one is the main one, and the rest are used only for development), it is necessary to use the database administration utility. You can also check the “Set blocking of routine tasks” checkbox in the database created on the server.

In addition, the ITS disks have a special processing “Task Console”, which allows you to edit the schedule background processes and change their activity.

Managing routine tasks of 1C databases from the updater

2018-11-20T15:18:30+00:00

In this note, we will go over the capabilities of the updater for managing routine tasks in databases.

First of all, in the item “More” -> “Manage routine tasks...”:

IN context menu dedicated database (or group of databases):

And finally, in templates for batch scripts (this allows you to perform operations on routine tasks from a script according to a schedule):

This is what the dialog for managing routine tasks in databases looks like:

What problems does it allow to solve in the right group bases (or one base)?

Selection of routine tasks

Please note that you can select a list of routine tasks in many operations below:

But in the selection dialog there may not be routine tasks specifically for your database:

In this case, you can indicate the names of the scheduled tasks you need in the “Your tasks...” section, for example, like this:

The names for such routine tasks can be taken directly from the report on all routine tasks (this is discussed).

Displays the current status of tasks

To do this, go to the "Withdraw" tab and click the "Withdraw..." button:

In the results we can see:

The launch of new scheduled tasks on the 1C server is enabled or disabled.
List of routine tasks in the database.
Their schedule.
Jobs are enabled or disabled.
If the last run of a task had an error, this error is displayed in red next to the task.

If necessary, in the feature settings, we can narrow the list of scheduled tasks, and also display only enabled tasks:

Turn off all or some tasks

To do this, go to the “Turn off” tab:

For all or selected scheduled tasks, the "Use" checkbox will be cleared.

Here is the result for one base (click to expand)

Include all or some tasks

To do this, go to the “Enable” tab:

For all or selected scheduled tasks, the "Use" checkbox will be selected.

Please note that the "Make" flag is available in this tab. backup copy base" in the lower left corner.

Here is the result for one base (click to expand)

We manage the launch of scheduled tasks on the 1C server

To do this, go to the “1C Server” tab:

Select “block” or “unblock” and click the “Run” button.

Setting up a task schedule

But what if we need to set up a schedule for launching a task (or group of tasks) in many databases at once?

To do this, go to the “Set up schedule” tab:

We set up the schedule (the dialogue and its capabilities completely coincide with the standard one in 1C itself) and click “Customize...”.

We launch tasks for execution

To do this, go to the “Run” tab:

Select the required tasks and click the “Run” button:

Saving task settings to an external file

Let's assume that we have ideally configured routine tasks in one of the databases and want to transfer these settings to all other databases.

To do this, we first upload all task settings in the ideal database to an external file:

Restoring task settings from an external file

And then we load this file with task settings into all other databases:

Just note that for this task (transferring job settings from one database to another), I chose the matching method by job name, and not by internal identifier.

Parting words

In general, that's all I wanted to tell you. I myself see many scenarios for using new features, but here I just briefly skimmed over the main points.