Amazon SageMaker provides a number of options for users who are looking for a solution to host their machine learning (ML) models. Of these options, one of the key features that SageMaker provides is real-time inference. Real-time inference workloads can have varying levels of requirements and service level agreements (SLAs) in terms of latency and throughput. Regardless of the use case, SageMaker offers a number of options that allow you to find the right balance of cost and performance to meet your business objectives.
There are many factors to consider when choosing the right real-time inference option for your business. For example, your business may have a model that must meet the strictest SLAs for latency and throughput with very predictable performance. For that use case, SageMaker provides SageMaker single model endpoints (SMEs), which allow you to deploy a single ML model against a logical endpoint. For other use cases, you can choose to manage cost and performance using SageMaker többmodell végpontok (MMEs), which allow you to specify multiple models to host behind a logical endpoint. Regardless of the option you may choose, SageMaker endpoints provide a scalable mechanism for even the most demanding enterprise users while providing value in a plethora of features, including árnyékváltozatok, automatikus méretezés, és natív integrációval amazonfelhőóra (további információért lásd CloudWatch metrikák többmodell végpont-telepítésekhez).
One option supported by SageMaker single and multi-model endpoints is NVIDIA Triton következtetés szerver. Triton supports various backends as engines to support the running and serving of various ML models for inference. For any Triton deployment, it’s crucial to know how the backend behavior impacts your workloads and what to expect so that you can be successful. In this post, we help you understand the Python backend that is supported by Triton on SageMaker so that you can make an informed decision for your workloads and achieve great results.
A SageMaker a Tritont kkv-kon és MME-ken keresztül biztosítja
The Python backend is available through SageMaker, which enables you to deploy mindkét egyetlen és a több modell endpoints with NVIDIA Triton Inference Server. Triton supports instance types that support GPUs, CPUs, and AWS Inferentia chips, which allow you to maximize the performance for your workloads. The following diagram illustrates the NVIDIA Triton Inference Server architecture.
Inference requests arrive at the server via either HTTP/REST vagy a C API and are then routed to the appropriate per-model scheduler. Triton implements több ütemezési és kötegelési algoritmus that can be configured on a model-by-model basis and can help tune performance. Each model’s scheduler optionally performs batching of inference requests and then passes the requests to the backend corresponding to the model type. The framework backend performs inference using the inputs provided in the batched requests to produce the requested outputs. The outputs are then formatted and returned in the response. The modell tároló is an object-based repository of the models powered by Amazon egyszerű tárolási szolgáltatás (Amazon S3) that Triton will make available for inferencing.
For MMEs, SageMaker takes care of traffic shaping to the endpoint and maintains optimal model copies on GPU instances for the best price performance. It continues to route traffic to the instance where the model is loaded. If the instance resources reach capacity due to high memory utilization, SageMaker unloads the least popular models from the container to free up resources to load more frequently used models. SageMaker MMEs offer capabilities for running multiple deep learning or ML models on the GPU at the same time with Triton Inference Server, which has been extended to implement the MME API szerződés. MMEs enable sharing GPU instances behind an endpoint across multiple models and dynamically load and unload models based on the incoming traffic. With this, you can easily achieve optimal price performance.
Amikor egy SageMaker MME HTTP-hívási kérelmet kap egy adott modellhez a használatával TargetModel
in the request along with the payload, it routes traffic to the right instance behind the endpoint where the target model is loaded. SageMaker takes care of model management behind the endpoint. It dynamically downloads models from Amazon S3 to the instance’s storage volume if the invoked model isn’t available on the instance storage volume. Then SageMaker loads the model to the NVIDIA Triton container’s memory on a GPU accelerated instance and serves the inference request. The GPU core is shared by all the models in an instance. For more information about SageMaker MMEs on GPUs, see Futtasson több mély tanulási modellt GPU-n az Amazon SageMaker többmodell végpontjaival.
A SageMaker MME-k vízszintesen skálázhatnak egy automatikus skálázási házirendet használva, és további GPU-számítási példányokat biztosíthatnak a megadott metrikák alapján. Amikor konfigurálja az automatikus skálázási csoportokat a SageMaker végpontokhoz, érdemes megfontolni SageMakerVariantInvocationsPerInstance
mint elsődleges kritérium az automatikus skálázási csoport skálázási jellemzőinek meghatározásához. Ezenkívül, attól függően, hogy a modelljei GPU-n vagy CPU-n futnak, fontolóra veheti a használatát CPUUtilization
or GPUUtilization
as additional criteria. Note that for single model endpoints, because the models deployed are all the same, it’s fairly straightforward to set proper policies to meet your SLAs. For multi-model endpoints, we recommend deploying similar models behind a given endpoint to have more steady predictable performance. In use cases where models of varying sizes and requirements are used, you may want to separate those workloads across multiple multi-model endpoints or spend some time fine-tuning your auto scaling group policy to obtain the best cost and performance balance.
Python backend runtime architecture
As the name suggests, the Python backend is for running models that are written and run in the Python language. Various use cases fall into this category, such as preprocessing or postprocessing steps composing a model ensemble. In other cases, the Python backend may be used as a wrapper to call a Python-based model or framework. Later in this post, we show an example of how you can use the Python backend to call a PyTorch T5 model. This may not always be the most performant option, but it showcases the flexibility that the Python backend provides.
The Python backend creates a runtime environment that creates Python processes using the host’s CPU and memory. You can still attain GPU acceleration if it’s exposed by a Python front end of the framework running the inference. No additional GPU acceleration occurs by using the Python backend itself, but there should be no compatibility errors for any Python process.
On SageMaker, the default Triton Python backend allocates 16 MB, and grows only by 1 MB. However, you can change this by setting the SageMaker environment variables SAGEMAKER_TRITON_SHM_DEFAULT_BYTE_SIZE
és a SAGEMAKER_TRITON_SHM_GROWTH_BYTE_SIZE
. These variables are important because it’s through shared memory that the Python backend will exchange tensors.
The following diagram shows the ensemble scheduler runtime architecture so that you can fine-tune the memory areas, including CPU addressable shared memory, that are used for inter-process communication between C++ and the Python process for exchanging tensors (input/output).
You can monitor resource utilization using CloudWatch, which has native integration with SageMaker.
To get started with the Python backend, you need to create a Python file that has a structure similar to the following code, which dictates the structure as well as how to interact with parameters and return values. Take note of the point in the lifecycle that the methods are called.
Kihasználva a model.py
methods, you can take on the responsibility to load models on a specific device (CPU or GPU) by writing the code in the model.py
file explicitly. Although other backends that Triton provides allow you to specify a KIND
attribútum a config.pbtxt
file to determine if the backend runs on CPU or GPU, it’s not applicable for the Python backend because the model is loaded in the respective device depending on the code written in model.py
, mint .to(device)
in torch. It’s important to note that if you explicitly load artifacts into memory or create temporary files, you reclaim your resources by cleaning up, which usually occurs in the finalize
method. Otherwise, you may experience unwanted situations such as memory leaks.
SageMaker notebook áttekintése
Aktivitáskövető NVIDIA Triton container image on SageMaker, you can now use Triton’s Python backend, which allows you to write your model logic in Python. For example, you can use this backend to run preprocessing and postprocessing code written in Python, or run a PyTorch Python script directly (instead of first converting it to TorchScript and then using the PyTorch backend). The python_backend GitHub repo contains the documentation and source for the backend.
In this section, we walk you through the példafüzet, which demonstrates how to use NVIDIA Triton Inference Server on an Amazon SageMaker MME with the GPU feature to deploy an T5 NLP model for translation.
Állítsa be a környezetet
Kezdjük a szükséges környezet beállításával. Telepítjük a modellfolyamat csomagolásához szükséges függőségeket, és a Triton Inference Server segítségével következtetéseket futtatunk. Meghatározzuk azt is AWS Identity and Access Management (IAM) szerepkör, amely hozzáférést biztosít a SageMaker számára a modelltermékekhez és az NVIDIA Tritonhoz Amazon Elastic Container Registry (Amazon ECR) image. You can use the following code example to retrieve the prebuilt Triton ECR image:
Generate model artifacts
In this example, we host a pre-trained T5-small Hugging Face PyTorch model using Triton’s Python háttérrendszer. Here we have the Python script modell.py, which implements all the logic to initialize the T5 model and run inference for the translation task. There are three main functions in the script:
- inicializálni – The initialize function is called one time when the model is being loaded. Implementing
initialize
opcionális.initialize
allows you to do any necessary initializations before running the model. This function allows the model to initialize any state associated with this model. - kivégez - A
execute
függvény meghívásra kerül, amikor egy következtetési kérés érkezik. Minden Python modellnek megvalósítania kell aexecute
funkció. Ban,-benexecute
function, you’re given a list ofInferenceRequest
objects. There are two modes of implementing this function: default and decoupled mode. The default mode is the most generic way you would like to implement your model and requires the execute function to return exactly one response per request. The decoupled mode allows you to send multiple responses for a request or not send any responses for a request. The mode you choose should depend on your use case—that is, whether or not you want to return decoupled responses from this model. In this example notebook, we use the default mode. - véglegesítése – Megvalósítás
finalize
is optional. This function allows you to do any cleanup necessary before the model is unloaded from Triton Inference Server.
Build the model repository
A Triton SageMakeren való használatához először be kell állítanunk a modell tároló folder containing the models we want to serve. For each model, we need to create a model directory consisting of the model artifact and define the config.pbtxt file to specify the model configuration that Triton uses to load and serve the model. To learn more about the config settings, refer to Modellkonfiguráció. The model repository structure for the T5 model is as follows:
Note that Triton has specific requirements for the model repository layout. Within the top-level model repository directory, each model has its own subdirectory containing the information for the corresponding model. Each model directory in Triton must have at least one numeric subdirectory representing a version of the model. Here, that is 1, representing version 1 of our T5 PyTorch model. Each model is run by a specific backend, so each version subdirectory must contain the model artifact required by that backend. Here, we are using the Python backend, and it requires the Python file that is used for serving (model.py). If we were using a PyTorch backend, a model.pt file would be required. For more details on naming conventions for model files, refer to Modell fájlok.
Every Python Triton model must provide a config.pbtxt file
describing the model configuration. To use this backend, you must set the backend
a modelled területén config.pbtxt
fájlt python
. The following code shows how to define the config file for the T5 PyTorch model being served through Triton’s Python backend:
In this configuration, we have defined the parameters section to provide an environment path. This is because to serve the Hugging Face T5 PyTorch model using Triton’s Python backend, we have PyTorch and Hugging Face transformers as dependencies. You need to create a custom run environment in the Python backend to include all the dependencies in this example. The alternative is to install Python and all the dependencies in the local environment. The custom run environment is only needed if you want portability across different systems that might not have the Python environment to run the inference. If a custom run environment is required for SageMaker, then this should be pointed out clearly. Currently, the Python backend only supports conda-pack erre a célra. conda-pack ensures that your Conda environment is portable. We follow the instructions from the Triton documentation for packaging dependencies to be used in the Python backend as the Conda environment TAR file. Running the bash script create_hf_env.sh creates the Conda environment containing PyTorch and Hugging Face transformers and packages it as a TAR file, and then we move it into the t5-pytorch model directory:
After we create the TAR file from the Conda environment, we place it in the model folder. The following code in the model config.pbtxt
file tells the Python backend to use this custom environment for your model:
parameters: { key: "EXECUTION_ENV_PATH", value: {string_value: "$$TRITON_MODEL_DIRECTORY/hf_env.tar.gz"}
}
Itt, $$TRITON_MODEL_DIRECTORY
helps provide the environment path relative to the model folder in the model repository, and is resolved to $pwd/model_repository/t5_pytorch
. Végül, hf_env.tar.gz
is the name we gave to our Conda environment file.
Next, we package our model as *.tar.gz
files for uploading to Amazon S3:
Hozzon létre egy SageMaker végpontot
Now that we have uploaded the model artifacts to Amazon S3, we can create a SageMaker multi-model endpoint. To create a SageMaker endpoint, we need to first create the SageMaker model object and endpoint configuration.
Először is meg kell határoznunk a kiszolgáló tartályt. A tároló definíciójában adja meg a ModelDataUrl
annak az S3-könyvtárnak a megadásához, amely tartalmazza az összes olyan modellt, amelyet a SageMaker többmodell-végpont az előrejelzések betöltéséhez és kiszolgálásához fog használni. Készlet Mode
nak nek MultiModel
to indicate SageMaker would create the endpoint with MME container specifications. See the following code:
Ezután létrehozzuk a SageMaker modell objektumot a create_model
boto3 API by specifying the ModelName and container definition:
Ezt a modellt használjuk egy végpont konfiguráció where we can specify the type and number of instances we want in the endpoint. Here we are deploying to a g5.2xlarge NVIDIA GPU instance:
We use this configuration to create a new SageMaker endpoint and wait for the deployment to finish:
The status will change to InService after the deployment is successful.
Hívja meg a SageMaker végponton tárolt modelljét
After the endpoint is running, we can use some sample raw data to perform inference using JSON as the payload format. For the inference request format, Triton uses the KFServing community standard következtetési protokollok. We can send inference requests to the multi-model endpoint using the invoke_enpoint
API. Meghatározzuk a TargetModel
in the invocation call and pass in the payload for each model type. See the following code:
A jegyzetfüzet a GitHub tárház.
Legjobb gyakorlatok
When using the Python backend, it can sometimes be complicated to optimize the workload for throughput and latency. You should consider the options available through the SageMaker and Triton environment variables that we discussed previously in regards to batch sizes, max delay, and other factors. In addition, you should be aware of the Python backend-specific configuration and the configuration of the underlying framework. The following are some best practices:
- If using PyTorch (or any other deep learning framework) module in the Python backend, consider experimenting with different values of intra/inter op thread pool size. Because each Python backend model instance runs in a separate process, limiting the number of threads per process prevents over-subscribing the system resources when scaling up the instance count.
- Even though the Python backend is highly flexible, it performs some extra data copies that can impact inference performance. For the best performance on GPU, consider using Triton’s TensorRT backend when possible.
- When using Python backend models in an ensemble, refer to Interoperability and GPU Support for a possible zero-copy transfer of Python backend tensors to other frameworks.
- Ön is használja a
instance_group_count
változó aconfig.pbtxt
file to add a worker process and increase throughput. Be aware that increasing this variable will increase the amount of resource consumption, including CPU and GPU utilization.
You can explore these options and parameters to get the desired performance characteristics you seek. As always, be aware that resources such as processor or memory consumption can change and should be monitored so you can fine-tune and optimize inference performance.
Következtetés
In this post, we dove deep into the Python backend that Triton Inference Server supports on SageMaker. This backend provides for both CPU and GPU acceleration of your models that are written and run in the Python language. There are many options to consider to get the best performance for inference, such as batch sizes, data input formats, and other factors that can be tuned to meet your needs. SageMaker allows you to use single model endpoints for guaranteed performance and multi-model endpoints to get a better balance of performance and cost savings. To get started with MME support for GPU, see Támogatott algoritmusok, keretrendszerek és példányok.
Meghívjuk Önt, hogy próbálja ki a Triton Inference Server konténereket a SageMakerben, és ossza meg visszajelzéseit és kérdéseit a megjegyzésekben.
A szerzőkről
James Parker az Amazon Web Services megoldástervezője. Az Amazonnal együttműködve technológiai megoldásokat tervez, épít és telepít az AWS-re, és különösen érdeklődik az AI és a gépi tanulás iránt. Szabadidejében szívesen keres új kultúrákat, új tapasztalatokat, és naprakész marad a legújabb technológiai trendekkel.
Dhawal Patel az AWS vezető gépi tanulási építésze. Az elosztott számítástechnikával és a mesterséges intelligenciával kapcsolatos problémákon a nagyvállalatoktól a közepes méretű startupokig számos szervezettel dolgozott együtt. A mély tanulásra összpontosít, beleértve az NLP-t és a számítógépes látást. Segít az ügyfeleknek abban, hogy nagy teljesítményű modellkövetkeztetést érjenek el az Amazon SageMakeren.
Melanie Li az AWS vezető AI/ML specialistája, Sydney-ben, Ausztráliában. Segít a vállalati ügyfeleknek az AWS legkorszerűbb AI/ML-eszközeit kihasználó megoldások kidolgozásában, és útmutatást ad a gépi tanulási megoldások megtervezéséhez és megvalósításához a legjobb gyakorlatok alapján. Szabadidejében szereti felfedezni a természetet a szabadban, és időt tölt családjával és barátaival.
Jiahong Liu az NVIDIA Cloud Service Provider csapatának megoldástervezője. Segíti az ügyfeleket a gépi tanulási és mesterséges intelligencia-megoldások elfogadásában, amelyek az NVIDIA gyorsított számítástechnikáját használják ki a képzési és következtetési kihívások megoldására. Szabadidejében szereti az origamit, a barkácsprojekteket és a kosárlabdát.
Kshitiz Gupta az NVIDIA megoldástervezője. Szívesen oktatja felhőügyfeleit az NVIDIA által kínált GPU AI-technológiákról, és segít nekik gépi tanulási és mély tanulási alkalmazásaik felgyorsításában. Munkán kívül szeret futni, túrázni és vadvilágot nézni.
- SEO által támogatott tartalom és PR terjesztés. Erősödjön még ma.
- PlatoAiStream. Web3 adatintelligencia. Felerősített tudás. Hozzáférés itt.
- A jövő pénzverése – Adryenn Ashley. Hozzáférés itt.
- Részvények vásárlása és eladása PRE-IPO társaságokban a PREIPO® segítségével. Hozzáférés itt.
- Forrás: https://aws.amazon.com/blogs/machine-learning/host-ml-models-on-amazon-sagemaker-using-triton-python-backend/
- :van
- :is
- :nem
- :ahol
- $ UP
- 1
- 10
- 100
- 11
- 12
- 23
- 7
- 8
- 9
- a
- Rólunk
- felgyorsult
- gyorsuló
- hozzáférés
- Fiók
- Elérése
- át
- hozzá
- mellett
- További
- cím
- címezhető
- Elfogadása
- Után
- ellen
- megállapodások
- AI
- AI / ML
- algoritmusok
- Minden termék
- kiosztja
- lehetővé
- lehetővé teszi, hogy
- mentén
- Is
- alternatív
- Bár
- mindig
- amazon
- Amazon SageMaker
- Az Amazon Web Services
- összeg
- an
- és a
- bármilyen
- api
- alkalmazható
- alkalmazások
- megfelelő
- építészet
- VANNAK
- területek
- érv
- mesterséges
- mesterséges intelligencia
- AS
- segítséget nyújt
- társult
- At
- Ausztrália
- auto
- elérhető
- tudatában van
- AWS
- háttér
- Egyenleg
- bázis
- alapján
- horpadás
- alap
- Kosárlabda
- BE
- mert
- óta
- előtt
- kezdődik
- mögött
- hogy
- BEST
- legjobb gyakorlatok
- Jobb
- között
- test
- mindkét
- épít
- üzleti
- de
- by
- C + +
- hívás
- hívott
- TUD
- képességek
- Kapacitás
- ami
- eset
- esetek
- Kategória
- kihívások
- változik
- jellemzők
- játékpénz
- A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a
- választja
- osztály
- Takarításra
- világosan
- ügyfél részére
- felhő
- kód
- COM
- Hozzászólások
- közlés
- közösség
- kompatibilitás
- bonyolult
- Kiszámít
- számítógép
- Számítógépes látás
- számítástechnika
- Configuration
- Fontolja
- Összeáll
- fogyasztás
- tartalmaz
- Konténer
- Konténerek
- tartalmaz
- tovább
- konvertáló
- Mag
- Megfelelő
- Költség
- költségmegtakarítás
- teremt
- készítette
- teremt
- kritériumok
- kritikus
- Jelenleg
- szokás
- Ügyfelek
- dátum
- találka
- döntés
- függetlenített
- mély
- mély tanulás
- alapértelmezett
- meghatározott
- késleltetés
- igényes
- mutatja
- attól
- telepíteni
- telepített
- bevezetéséhez
- bevetés
- Design
- kívánatos
- részletek
- Határozzuk meg
- eszköz
- DICT
- diktálja
- különböző
- közvetlenül
- tárgyalt
- megosztott
- elosztott számítástechnika
- diy
- do
- dokumentáció
- domainek
- galamb
- letöltések
- két
- dinamikusan
- minden
- könnyen
- nevelése
- bármelyik
- más
- lehetővé
- lehetővé teszi
- végén
- Endpoint
- Motorok
- Angol
- biztosítja
- Vállalkozás
- Vállalatok
- Környezet
- hibák
- Még
- Minden
- pontosan
- példa
- csere
- cseréje
- kivégez
- végrehajtás
- létező
- Kilépés
- vár
- tapasztalat
- Tapasztalatok
- feltárása
- kitett
- külön-
- Arc
- tényezők
- meglehetősen
- Esik
- hamis
- család
- Funkció
- Jellemzők
- Visszacsatolás
- mező
- filé
- Fájlok
- Végül
- Találjon
- befejezni
- vezetéknév
- Rugalmasság
- rugalmas
- koncentrál
- következik
- következő
- következik
- A
- formátum
- talált
- Keretrendszer
- keretek
- Ingyenes
- gyakran
- barátok
- ból ből
- front
- Front end
- funkció
- funkcionális
- funkciók
- Német
- kap
- GitHub
- adott
- ad
- GPU
- GPU
- nagy
- Csoport
- Csoportok
- növekszik
- Garantált
- útmutatást
- Legyen
- he
- segít
- segít
- neki
- itt
- Magas
- nagy teljesítményű
- nagyon
- övé
- vízszintesen
- vendéglátó
- házigazdája
- Ház
- Hogyan
- How To
- azonban
- HTML
- http
- HTTPS
- ID
- Identitás
- if
- illusztrálja
- kép
- Hatás
- Hatások
- végre
- végre
- végrehajtási
- munkagépek
- importál
- fontos
- in
- Más
- tartalmaz
- Beleértve
- Bejövő
- Növelje
- növekvő
- jelez
- információ
- tájékoztatták
- bemenet
- bemenet
- telepíteni
- példa
- helyette
- utasítás
- integráció
- Intelligencia
- kölcsönhatásba
- kamat
- bele
- meghívni
- hivatkozni
- IT
- ITS
- maga
- jpg
- json
- Kulcs
- kulcsok
- Kedves
- Ismer
- nyelv
- nagy
- Nagy vállalkozások
- Késleltetés
- a későbbiekben
- legutolsó
- elrendezés
- Szivárgás
- TANUL
- tanulás
- legkevésbé
- Hossz
- szint
- szintek
- Tőkeáttétel
- erőfölény
- életciklus
- mint
- Lista
- kiszámításának
- terhelések
- helyi
- logika
- logikus
- keres
- szeret
- gép
- gépi tanulás
- készült
- Fő
- fenntartja
- csinál
- kezelése
- vezetés
- sok
- térképészet
- max
- Maximize
- Lehet..
- mechanizmus
- Találkozik
- Memory design
- módszer
- mód
- Metrics
- esetleg
- ML
- Mód
- modell
- modellek
- módok
- Modulok
- monitor
- ellenőrizni
- több
- a legtöbb
- mozog
- Többmodell végpont
- többszörös
- kell
- név
- elnevezési
- bennszülött
- Természet
- elengedhetetlen
- Szükség
- szükséges
- igények
- Új
- NLP
- nem
- jegyzetfüzet
- Most
- szám
- számtalan
- Nvidia
- tárgy
- célok
- objektumok
- szerez
- of
- ajánlat
- Ajánlatok
- on
- egyszer
- ONE
- csak
- OP
- optimálisan
- Optimalizálja
- opció
- Opciók
- or
- szervezetek
- OS
- Más
- másképp
- mi
- ki
- szabadban
- teljesítmény
- kívül
- saját
- csomag
- csomagok
- csomagolás
- paraméterek
- különös
- elhalad
- bérletek
- ösvény
- Teljesít
- teljesítmény
- Előadja
- csővezeték
- Hely
- Plató
- Platón adatintelligencia
- PlatoData
- játék
- rengeteg
- pont
- Politikák
- politika
- medence
- Népszerű
- lehetséges
- állás
- powered
- gyakorlat
- Kiszámítható
- Tippek
- megakadályozza
- korábban
- ár
- elsődleges
- Fő
- problémák
- folyamat
- Folyamatok
- Processzor
- gyárt
- projektek
- megfelelő
- ingatlanait
- ad
- feltéve,
- ellátó
- biztosít
- amely
- ellátás
- cél
- Piton
- pytorch
- Kérdések
- emel
- kezdve
- Nyers
- el
- real-time
- kap
- ajánl
- Tekintet nélkül
- tekintetében
- vidék
- összefüggő
- raktár
- képviselő
- kérni
- kéri
- kötelező
- követelmények
- megköveteli,
- megoldódott
- forrás
- Tudástár
- azok
- válasz
- válaszok
- felelősség
- Eredmények
- visszatérés
- Visszatér
- jobb
- Szerep
- Útvonal
- útvonalak
- futás
- futás
- sagemaker
- azonos
- Megtakarítás
- skálázható
- Skála
- skálázás
- ütemezés
- Rész
- lát
- Keresnek
- keres
- MAGA
- küld
- idősebb
- különálló
- szolgál
- szolgálja
- szolgáltatás
- Szolgáltató
- Szolgáltatások
- szolgáló
- készlet
- beállítás
- beállítások
- formálás
- Megosztás
- megosztott
- megosztás
- ő
- kellene
- előadás
- Műsorok
- hasonló
- Egyszerű
- egyetlen
- helyzetek
- Méret
- méretek
- KKV-k
- So
- megoldások
- Megoldások
- néhány
- forrás
- szakember
- különleges
- specifikációk
- meghatározott
- költ
- standard
- kezdődött
- Startups
- Állami
- csúcs-
- Állapot
- állandó
- Lépései
- Még mindig
- tárolás
- egyértelmű
- Húr
- struktúra
- sikeres
- ilyen
- javasolja,
- támogatás
- Támogatott
- Támogatja
- sydney
- rendszer
- Systems
- Vesz
- tart
- cél
- Feladat
- csapat
- Technologies
- Technológia
- megmondja
- ideiglenes
- feltételek
- hogy
- A
- az információ
- azok
- Őket
- akkor
- Ott.
- Ezek
- ezt
- azok
- bár?
- három
- Keresztül
- áteresztőképesség
- idő
- nak nek
- szerszámok
- felső szint
- fáklya
- forgalom
- Képzések
- átruházás
- transzformerek
- fordít
- Fordítás
- Trends
- Triton
- megpróbál
- kettő
- típus
- típusok
- mögöttes
- megért
- felesleges
- feltöltve
- Feltöltés
- upon
- UPS
- us
- használ
- használati eset
- használt
- Felhasználók
- segítségével
- rendszerint
- kihasználva
- érték
- Értékek
- különféle
- változat
- nagyon
- keresztül
- látomás
- kötet
- várjon
- akar
- őrzés
- Út..
- we
- háló
- webes szolgáltatások
- JÓL
- voltak
- Mit
- amikor
- bármikor
- vajon
- ami
- míg
- WHO
- lesz
- val vel
- belül
- csodálatos
- Munka
- dolgozott
- munkás
- művek
- lenne
- ír
- írás
- írott
- te
- A te
- zephyrnet