M

MLOG

தமிழ்

குபெர்நெடஸ் ஆபரேட்டர்கள் பற்றிய ஆழமான பார்வை. சிக்கலான பயன்பாடுகள் மற்றும் தனிப்பயன் வளங்களை நிர்வகிப்பதை இது எப்படி எளிதாக்குகிறது மற்றும் தானியக்கமாக்குகிறது என்பதை விளக்குகிறது. உங்கள் சொந்த ஆபரேட்டர்களை உருவாக்குவது மற்றும் பயன்படுத்துவது எப்படி என்பதை அறியுங்கள்.

குபெர்நெடஸ் ஆபரேட்டர்கள்: தனிப்பயன் வள மேலாண்மையை தானியக்கமாக்குதல்

குபெர்நெடஸ், நாம் பயன்பாடுகளை வரிசைப்படுத்தி நிர்வகிக்கும் முறையில் ஒரு புரட்சியை ஏற்படுத்தியுள்ளது. இருப்பினும், சிக்கலான, நிலைத்தன்மையுள்ள பயன்பாடுகளை நிர்வகிப்பது இன்னும் சவாலானதாக இருக்கலாம். இங்குதான் குபெர்நெடஸ் ஆபரேட்டர்கள் வருகின்றன, இது பயன்பாட்டு மேலாண்மையை தானியக்கமாக்குவதற்கும் குபெர்நெடஸின் திறன்களை விரிவுபடுத்துவதற்கும் ஒரு சக்திவாய்ந்த வழியை வழங்குகிறது.

குபெர்நெடஸ் ஆபரேட்டர்கள் என்றால் என்ன?

ஒரு குபெர்நெடஸ் ஆபரேட்டர் என்பது ஒரு பயன்பாட்டுக்கு-குறிப்பிட்ட கட்டுப்பாட்டாளர் ஆகும், இது சிக்கலான பயன்பாடுகளை நிர்வகிக்க குபெர்நெடஸ் API-ஐ விரிவுபடுத்துகிறது. இதை ஒரு குறிப்பிட்ட பயன்பாட்டிற்காக வடிவமைக்கப்பட்ட தானியங்கு கணினி நிர்வாகியாக நினையுங்கள். ஆபரேட்டர்கள் ஒரு குறிப்பிட்ட பயன்பாட்டை இயக்குவதற்கான கள அறிவை உள்ளடக்கியுள்ளன, இது உங்களை ஒரு அறிவிப்பு, தானியங்கு மற்றும் மீண்டும் செய்யக்கூடிய வழியில் நிர்வகிக்க அனுமதிக்கிறது.

பாரம்பரிய குபெர்நெடஸ் கட்டுப்பாட்டாளர்களைப் போலல்லாமல், Pods மற்றும் Services போன்ற முக்கிய வளங்களை நிர்வகிக்கும் ஆபரேட்டர்கள், தனிப்பயன் வள வரையறைகள் (Custom Resource Definitions - CRDs) மூலம் வரையறுக்கப்பட்ட தனிப்பயன் வளங்களை நிர்வகிக்கின்றன. இது உங்கள் சொந்த பயன்பாட்டுக்கு-குறிப்பிட்ட வளங்களை வரையறுத்து, அவற்றை குபெர்நெடஸ் தானாகவே நிர்வகிக்க அனுமதிக்கிறது.

குபெர்நெடஸ் ஆபரேட்டர்களை ஏன் பயன்படுத்த வேண்டும்?

சிக்கலான பயன்பாடுகளை நிர்வகிப்பதற்கு ஆபரேட்டர்கள் பல முக்கிய நன்மைகளை வழங்குகின்றன:

தனிப்பயன் வள வரையறைகளை (CRDs) புரிந்துகொள்ளுதல்

தனிப்பயன் வள வரையறைகள் (CRDs) குபெர்நெடஸ் ஆபரேட்டர்களின் அடித்தளமாகும். CRD-கள் உங்கள் சொந்த தனிப்பயன் வள வகைகளை வரையறுப்பதன் மூலம் குபெர்நெடஸ் API-ஐ விரிவுபடுத்த உங்களை அனுமதிக்கின்றன. இந்த வளங்கள் Pods அல்லது Services போன்ற பிற குபெர்நெடஸ் வளங்களைப் போலவே கருதப்படுகின்றன, மேலும் `kubectl` மற்றும் பிற குபெர்நெடஸ் கருவிகளைப் பயன்படுத்தி நிர்வகிக்கப்படலாம்.

CRD-கள் எவ்வாறு செயல்படுகின்றன என்பது இங்கே:

  1. உங்கள் தனிப்பயன் வளத்திற்கான ஸ்கீமா மற்றும் சரிபார்ப்பு விதிகளைக் குறிப்பிடும் ஒரு CRD-ஐ நீங்கள் வரையறுக்கிறீர்கள்.
  2. உங்கள் குபெர்நெடஸ் கிளஸ்டரில் CRD-ஐ வரிசைப்படுத்துகிறீர்கள்.
  3. விரும்பிய உள்ளமைவைக் குறிப்பிட்டு, உங்கள் தனிப்பயன் வளத்தின் நிகழ்வுகளை உருவாக்குகிறீர்கள்.
  4. இந்த தனிப்பயன் வளங்களில் ஏற்படும் மாற்றங்களை ஆபரேட்டர் கண்காணித்து, விரும்பிய நிலையை உண்மையான நிலையுடன் சரிசெய்ய நடவடிக்கை எடுக்கிறது.

உதாரணமாக, ஒரு ஆபரேட்டரைப் பயன்படுத்தி ஒரு தரவுத்தள பயன்பாட்டை நிர்வகிக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம். `பெயர்`, `பதிப்பு`, `சேமிப்பு அளவு`, மற்றும் `பிரதிகள்` போன்ற புலங்களுடன் `Database` என்ற ஒரு CRD-ஐ நீங்கள் வரையறுக்கலாம். ஆபரேட்டர் பின்னர் `Database` வளங்களில் ஏற்படும் மாற்றங்களைக் கண்காணித்து, அதற்கேற்ப அடிப்படை தரவுத்தள நிகழ்வுகளை உருவாக்கும் அல்லது புதுப்பிக்கும்.

குபெர்நெடஸ் ஆபரேட்டர்கள் எவ்வாறு செயல்படுகின்றன

குபெர்நெடஸ் ஆபரேட்டர்கள் தனிப்பயன் வள வரையறைகளை (CRDs) தனிப்பயன் கட்டுப்பாட்டாளர்களுடன் இணைப்பதன் மூலம் செயல்படுகின்றன. கட்டுப்பாட்டாளர் தனிப்பயன் வளங்களில் ஏற்படும் மாற்றங்களைக் கண்காணித்து, விரும்பிய நிலையை உண்மையான நிலையுடன் சரிசெய்ய நடவடிக்கை எடுக்கிறது. இந்த செயல்முறை பொதுவாக பின்வரும் படிகளை உள்ளடக்கியது:

  1. நிகழ்வுகளைக் கண்காணித்தல்: ஆபரேட்டர் தனிப்பயன் வளங்கள் தொடர்பான உருவாக்கம், நீக்கம் அல்லது புதுப்பிப்புகள் போன்ற நிகழ்வுகளைக் கண்காணிக்கிறது.
  2. நிலையைச் சரிசெய்தல்: ஒரு நிகழ்வு ஏற்படும்போது, ஆபரேட்டர் பயன்பாட்டின் நிலையைச் சரிசெய்கிறது. இது விரும்பிய நிலையை (தனிப்பயன் வளத்தில் வரையறுக்கப்பட்டது) உண்மையான நிலையுடன் ஒப்பிட்டு, அவற்றை சீரமைக்க நடவடிக்கை எடுப்பதை உள்ளடக்கியது.
  3. வளங்களை நிர்வகித்தல்: விரும்பிய நிலையை அடைய குபெர்நெடஸ் வளங்களை (Pods, Services, Deployments, போன்றவை) ஆபரேட்டர் உருவாக்குகிறது, புதுப்பிக்கிறது அல்லது நீக்குகிறது.
  4. பிழைகளைக் கையாளுதல்: பயன்பாடு ஒரு நிலையான நிலையில் இருப்பதை உறுதிசெய்ய, ஆபரேட்டர் பிழைகளைக் கையாண்டு தோல்வியுற்ற செயல்பாடுகளை மீண்டும் முயற்சிக்கிறது.
  5. கருத்துக்களை வழங்குதல்: ஆரோக்கிய சோதனைகள் மற்றும் வளப் பயன்பாடு போன்ற பயன்பாட்டின் நிலை குறித்த கருத்துக்களை ஆபரேட்டர் வழங்குகிறது.

சரிசெய்தல் வளையம் (reconcile loop) தான் ஆபரேட்டரின் தர்க்கத்தின் மையமாகும். இது தொடர்ந்து பயன்பாட்டின் நிலையைக் கண்காணித்து, விரும்பிய நிலையை பராமரிக்க நடவடிக்கை எடுக்கிறது. இந்த வளையம் பொதுவாக தேவையான செயல்பாடுகளைச் செய்யும் ஒரு சரிசெய்தல் செயல்பாட்டைப் (reconciliation function) பயன்படுத்தி செயல்படுத்தப்படுகிறது.

உங்கள் சொந்த குபெர்நெடஸ் ஆபரேட்டரை உருவாக்குதல்

குபெர்நெடஸ் ஆபரேட்டர்களை உருவாக்க பல கருவிகள் மற்றும் கட்டமைப்புகள் உங்களுக்கு உதவக்கூடும்:

ஆபரேட்டர் கட்டமைப்பைப் பயன்படுத்தி ஒரு ஆபரேட்டரை உருவாக்குவதில் உள்ள படிகளின் எளிமையான கண்ணோட்டம் இங்கே:

  1. ஒரு தனிப்பயன் வள வரையறையை (CRD) வரையறுத்தல்: உங்கள் பயன்பாட்டின் விரும்பிய நிலையை விவரிக்கும் ஒரு CRD-ஐ உருவாக்கவும். இது உங்கள் தனிப்பயன் வளத்திற்கான ஸ்கீமா மற்றும் சரிபார்ப்பு விதிகளை வரையறுக்கும்.
  2. ஆபரேட்டர் குறியீட்டை உருவாக்குதல்: உங்கள் CRD-ஐ அடிப்படையாகக் கொண்டு ஆரம்ப ஆபரேட்டர் குறியீட்டை உருவாக்க ஆபரேட்டர் SDK-ஐப் பயன்படுத்தவும். இது தேவையான கட்டுப்பாட்டாளர்கள் மற்றும் வள வரையறைகளை உருவாக்கும்.
  3. சரிசெய்தல் தர்க்கத்தை செயல்படுத்துதல்: விரும்பிய நிலையை (தனிப்பயன் வளத்தில் வரையறுக்கப்பட்டது) உண்மையான நிலையுடன் ஒப்பிட்டு, அவற்றை சீரமைக்க நடவடிக்கை எடுக்கும் சரிசெய்தல் தர்க்கத்தை செயல்படுத்தவும். இது உங்கள் ஆபரேட்டரின் செயல்பாட்டின் மையமாகும்.
  4. ஆபரேட்டரை உருவாக்கி வரிசைப்படுத்துதல்: ஆபரேட்டர் இமேஜை உருவாக்கி உங்கள் குபெர்நெடஸ் கிளஸ்டரில் வரிசைப்படுத்தவும்.
  5. சோதித்து மீண்டும் செய்யவும்: உங்கள் ஆபரேட்டரை முழுமையாக சோதித்து, அதன் செயல்பாட்டையும் நம்பகத்தன்மையையும் மேம்படுத்த குறியீட்டை மீண்டும் செய்யவும்.

ஆபரேட்டர் கட்டமைப்பைப் பயன்படுத்தி ஒரு அடிப்படை உதாரணத்துடன் விளக்குவோம். ஒரு எளிய `Memcached` வரிசைப்படுத்தலை நிர்வகிக்கும் ஒரு ஆபரேட்டரை உருவாக்க விரும்புகிறீர்கள் என்று வைத்துக்கொள்வோம்.

1. CRD-ஐ வரையறுத்தல்:

பின்வரும் CRD வரையறையுடன் ஒரு `memcached.yaml` கோப்பை உருவாக்கவும்:


apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: memcacheds.cache.example.com
spec:
  group: cache.example.com
  versions:
    - name: v1alpha1
      served: true
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                size:
                  type: integer
                  description: Size is the number of Memcached instances
              required: ["size"]
  scope: Namespaced
  names:
    plural: memcacheds
    singular: memcached
    kind: Memcached
    shortNames: ["mc"]

இந்த CRD, இயக்கப்பட வேண்டிய Memcached நிகழ்வுகளின் எண்ணிக்கையைக் குறிப்பிடும் `size` புலத்துடன் ஒரு `Memcached` வளத்தை வரையறுக்கிறது.

2. ஆபரேட்டர் குறியீட்டை உருவாக்குதல்:

ஆரம்ப ஆபரேட்டர் குறியீட்டை உருவாக்க ஆபரேட்டர் SDK-ஐப் பயன்படுத்தவும்:


operator-sdk init --domain=example.com --repo=github.com/example/memcached-operator
operator-sdk create api --group=cache --version=v1alpha1 --kind=Memcached --resource --controller

இது உங்கள் ஆபரேட்டருக்கான தேவையான கோப்புகள் மற்றும் கோப்பகங்களை உருவாக்கும், இதில் கட்டுப்பாட்டாளர் குறியீடு மற்றும் வள வரையறைகள் அடங்கும்.

3. சரிசெய்தல் தர்க்கத்தை செயல்படுத்துதல்:

சரிசெய்தல் தர்க்கத்தை செயல்படுத்த `controllers/memcached_controller.go` கோப்பைத் திருத்தவும். இந்த செயல்பாடு, `Memcached` வளத்தில் வரையறுக்கப்பட்ட விரும்பிய நிலையின் அடிப்படையில் Memcached வரிசைப்படுத்தல்களை உருவாக்கும், புதுப்பிக்கும் அல்லது நீக்கும்.


func (r *MemcachedReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
	log := r.Log.WithValues("memcached", req.NamespacedName)

	// Fetch the Memcached instance
	memcached := &cachev1alpha1.Memcached{}
	err := r.Get(ctx, req.NamespacedName, memcached)
	if err != nil {
		if errors.IsNotFound(err) {
			// Request object not found, could have been deleted after reconcile request.
			// Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
			// Return and don't requeue
			log.Info("Memcached resource not found. Ignoring since object must be deleted")
			return ctrl.Result{}, nil
		}
		// Error reading the object - requeue the request.
		log.Error(err, "Failed to get Memcached")
		return ctrl.Result{}, err
	}

	// Define a new Deployment object
	deployment := &appsv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name:      memcached.Name,
			Namespace: memcached.Namespace,
		},
		Spec: appsv1.DeploymentSpec{
			Replicas: &memcached.Spec.Size,
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{
					"app": memcached.Name,
				},
			},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						"app": memcached.Name,
					},
				},
				Spec: corev1.PodSpec{
					Containers: []corev1.Container{
						{
							Name:  "memcached",
							Image: "memcached:1.6.17-alpine",
							Ports: []corev1.ContainerPort{
								{
									ContainerPort: 11211,
								},
							},
						},
					},
				},
			},
		},
	}

	// Set Memcached instance as the owner and controller
	if err := ctrl.SetControllerReference(memcached, deployment, r.Scheme);
		err != nil {
			log.Error(err, "Failed to set controller reference")
			return ctrl.Result{}, err
	}

	// Check if this Deployment already exists
	found := &appsv1.Deployment{}
	err = r.Get(ctx, types.NamespacedName{
		Name:      deployment.Name,
		Namespace: deployment.Namespace,
	}, found)
	if err != nil && errors.IsNotFound(err) {
		log.Info("Creating a new Deployment", "Deployment.Namespace", deployment.Namespace, "Deployment.Name", deployment.Name)
		err = r.Create(ctx, deployment)
		if err != nil {
			log.Error(err, "Failed to create new Deployment", "Deployment.Namespace", deployment.Namespace, "Deployment.Name", deployment.Name)
			return ctrl.Result{}, err
		}

		// Deployment created successfully - return and requeue
		return ctrl.Result{Requeue: true}, nil
	} else if err != nil {
		log.Error(err, "Failed to get Deployment")
		return ctrl.Result{}, err
	}

	// Ensure the deployment size is the same as the spec
	size := memcached.Spec.Size
	if *found.Spec.Replicas != size {
		log.Info("Updating Deployment", "Deployment.Namespace", deployment.Namespace, "Deployment.Name", deployment.Name)
		found.Spec.Replicas = &size
		err = r.Update(ctx, found)
		if err != nil {
			log.Error(err, "Failed to update Deployment", "Deployment.Namespace", deployment.Namespace, "Deployment.Name", deployment.Name)
			return ctrl.Result{}, err
		}
		// Spec updated - return and requeue
		return ctrl.Result{Requeue: true}, nil
	}

	// Deployment already exists - don't requeue
	log.Info("Skip reconcile: Deployment already exists", "Deployment.Namespace", deployment.Namespace, "Deployment.Name", deployment.Name)
	return ctrl.Result{}, nil
}

இந்த உதாரணம் சரிசெய்தல் தர்க்கத்தின் மிகவும் எளிமையான பதிப்பாகும். ஒரு உற்பத்திக்கு-தயாரான ஆபரேட்டருக்கு மிகவும் வலுவான பிழை கையாளுதல், பதிவுசெய்தல் மற்றும் உள்ளமைவு விருப்பங்கள் தேவைப்படும்.

4. ஆபரேட்டரை உருவாக்கி வரிசைப்படுத்துதல்:

ஆபரேட்டர் இமேஜை உருவாக்கி `make deploy` ஐப் பயன்படுத்தி உங்கள் குபெர்நெடஸ் கிளஸ்டரில் வரிசைப்படுத்தவும்.

5. ஒரு Memcached வளத்தை உருவாக்குதல்:

பின்வரும் உள்ளடக்கத்துடன் ஒரு `memcached-instance.yaml` கோப்பை உருவாக்கவும்:


apiVersion: cache.example.com/v1alpha1
kind: Memcached
metadata:
  name: memcached-sample
spec:
  size: 3

`kubectl apply -f memcached-instance.yaml` ஐப் பயன்படுத்தி இந்த கோப்பை உங்கள் கிளஸ்டரில் பயன்படுத்தவும்.

ஆபரேட்டர் இப்போது 3 Memcached நிகழ்வுகளுடன் ஒரு வரிசைப்படுத்தலை உருவாக்கும்.

குபெர்நெடஸ் ஆபரேட்டர்களை உருவாக்குவதற்கான சிறந்த நடைமுறைகள்

திறமையான குபெர்நெடஸ் ஆபரேட்டர்களை உருவாக்க கவனமான திட்டமிடல் மற்றும் செயல்படுத்தல் தேவை. மனதில் கொள்ள வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

குபெர்நெடஸ் ஆபரேட்டர்களின் நிஜ-உலக எடுத்துக்காட்டுகள்

பல நிறுவனங்கள் உற்பத்தியில் சிக்கலான பயன்பாடுகளை நிர்வகிக்க குபெர்நெடஸ் ஆபரேட்டர்களைப் பயன்படுத்துகின்றன. இங்கே சில எடுத்துக்காட்டுகள்:

இவை கிடைக்கக்கூடிய பல குபெர்நெடஸ் ஆபரேட்டர்களின் சில எடுத்துக்காட்டுகள் மட்டுமே. குபெர்நெடஸ் பயன்பாடு தொடர்ந்து வளரும்போது, இன்னும் அதிகமான ஆபரேட்டர்கள் வெளிவருவதைக் காணலாம், இது பரந்த அளவிலான பயன்பாடுகளின் மேலாண்மையை எளிதாக்கும்.

குபெர்நெடஸ் ஆபரேட்டர்களுக்கான பாதுகாப்பு பரிசீலனைகள்

குபெர்நெடஸ் ஆபரேட்டர்கள், ஒரு குபெர்நெடஸ் கிளஸ்டரில் இயங்கும் எந்தவொரு பயன்பாட்டையும் போலவே, கவனமான பாதுகாப்பு பரிசீலனைகள் தேவை. ஆபரேட்டர்கள் பெரும்பாலும் கிளஸ்டர் வளங்களை நிர்வகிக்க உயர்ந்த சலுகைகளைக் கொண்டிருப்பதால், அங்கீகரிக்கப்படாத அணுகல் மற்றும் தீங்கிழைக்கும் செயல்பாடுகளைத் தடுக்க பொருத்தமான பாதுகாப்பு நடவடிக்கைகளைச் செயல்படுத்துவது முக்கியம்.

குபெர்நெடஸ் ஆபரேட்டர்களுக்கான சில முக்கிய பாதுகாப்பு பரிசீலனைகள் இங்கே:

இந்த பாதுகாப்பு நடவடிக்கைகளைச் செயல்படுத்துவதன் மூலம், பாதுகாப்பு மீறல்களின் அபாயத்தை நீங்கள் கணிசமாகக் குறைக்கலாம் மற்றும் உங்கள் குபெர்நெடஸ் ஆபரேட்டர்களை தீங்கிழைக்கும் செயல்பாடுகளிலிருந்து பாதுகாக்கலாம்.

குபெர்நெடஸ் ஆபரேட்டர்களின் எதிர்காலம்

குபெர்நெடஸ் ஆபரேட்டர்கள் வேகமாக வளர்ந்து வருகின்றன மற்றும் குபெர்நெடஸ் சுற்றுச்சூழல் அமைப்பின் ஒரு முக்கிய பகுதியாக மாறி வருகின்றன. குபெர்நெடஸ் பயன்பாடு தொடர்ந்து வளரும்போது, ஆபரேட்டர் துறையில் இன்னும் அதிகமான புதுமைகளை நாம் எதிர்பார்க்கலாம்.

குபெர்நெடஸ் ஆபரேட்டர்களின் எதிர்காலத்தை வடிவமைக்கும் சில போக்குகள் இங்கே:

முடிவுரை

குபெர்நெடஸ் ஆபரேட்டர்கள் சிக்கலான பயன்பாடுகளின் மேலாண்மையை தானியக்கமாக்கவும் குபெர்நெடஸின் திறன்களை விரிவுபடுத்தவும் ஒரு சக்திவாய்ந்த வழியை வழங்குகின்றன. தனிப்பயன் வளங்களை வரையறுத்து மற்றும் தனிப்பயன் கட்டுப்பாட்டாளர்களைச் செயல்படுத்துவதன் மூலம், ஆபரேட்டர்கள் உங்களை ஒரு அறிவிப்பு, தானியங்கு மற்றும் மீண்டும் செய்யக்கூடிய வழியில் பயன்பாடுகளை நிர்வகிக்க அனுமதிக்கின்றன. குபெர்நெடஸ் பயன்பாடு தொடர்ந்து வளரும்போது, ஆபரேட்டர்கள் கிளவுட்-நேட்டிவ் நிலப்பரப்பின் ஒரு முக்கிய பகுதியாக மாறும்.

குபெர்நெடஸ் ஆபரேட்டர்களை ஏற்றுக்கொள்வதன் மூலம், நிறுவனங்கள் பயன்பாட்டு மேலாண்மையை எளிதாக்கலாம், செயல்பாட்டுச் சுமையைக் குறைக்கலாம் மற்றும் அவற்றின் பயன்பாடுகளின் ஒட்டுமொத்த நம்பகத்தன்மை மற்றும் அளவிடுதலை மேம்படுத்தலாம். நீங்கள் தரவுத்தளங்கள், கண்காணிப்பு அமைப்புகள் அல்லது பிற சிக்கலான பயன்பாடுகளை நிர்வகித்தாலும், குபெர்நெடஸ் ஆபரேட்டர்கள் உங்கள் செயல்பாடுகளை நெறிப்படுத்தவும் குபெர்நெடஸின் முழு திறனையும் திறக்கவும் உதவும்.

இது ஒரு வளர்ந்து வரும் துறையாகும், எனவே உங்கள் நிறுவனத்தில் குபெர்நெடஸ் ஆபரேட்டர்களை திறம்படப் பயன்படுத்த சமீபத்திய மேம்பாடுகள் மற்றும் சிறந்த நடைமுறைகளுடன் புதுப்பித்த நிலையில் இருப்பது முக்கியம். ஆபரேட்டர்களைச் சுற்றியுள்ள சமூகம் துடிப்பானது மற்றும் ஆதரவானது, நீங்கள் வெற்றிபெற உதவும் வளங்கள் மற்றும் நிபுணத்துவத்தின் செல்வத்தை வழங்குகிறது.

குபெர்நெடஸ் ஆபரேட்டர்கள்: தனிப்பயன் வள மேலாண்மையை தானியக்கமாக்குதல் | MLOG