Quarkus, AMQ ഓൺലൈൻ എന്നിവ ഉപയോഗിച്ച് Red Hat OpenShift പ്ലാറ്റ്‌ഫോമിലെ ക്ലൗഡ്-നേറ്റീവ് സന്ദേശമയയ്‌ക്കൽ

എല്ലാവർക്കും ഹായ്! ഇതാ - ക്വാർക്കസ് പരമ്പരയിലെ ഞങ്ങളുടെ അവസാന പോസ്റ്റ്! (വേണം, ഞങ്ങളുടെ വെബിനാർ കാണുക "ഇതാണ് ക്വാർക്കസ് - കുബർനെറ്റസ് നേറ്റീവ് ജാവ ഫ്രെയിംവർക്ക്". ആദ്യം മുതൽ എങ്ങനെ ആരംഭിക്കാം അല്ലെങ്കിൽ റെഡിമെയ്ഡ് പരിഹാരങ്ങൾ കൈമാറുന്നത് എങ്ങനെയെന്ന് ഞങ്ങൾ കാണിച്ചുതരാം)

В മുമ്പത്തെ ഈ പോസ്റ്റിൽ, ജാവ ആപ്ലിക്കേഷനുകൾ നവീകരിക്കുന്നതിന്റെ ഫലമായി ലഭിച്ച മെച്ചപ്പെടുത്തലുകൾ കണക്കാക്കാൻ ഉപയോഗിക്കാവുന്ന പ്രസക്തമായ ടൂളുകൾ ഞങ്ങൾ പരിശോധിച്ചു.

പതിപ്പ് 0.17.0 മുതൽ, ക്വാർക്കസ് വിപുലമായ സന്ദേശ ക്യൂയിംഗ് പ്രോട്ടോക്കോൾ ഉപയോഗത്തെ പിന്തുണയ്ക്കുന്നു (എഎംക്യുപി), ഇത് ആപ്ലിക്കേഷനുകൾക്കും ഓർഗനൈസേഷനുകൾക്കുമിടയിൽ ബിസിനസ്സ് സന്ദേശങ്ങൾ കൈമാറുന്നതിനുള്ള ഒരു ഓപ്പൺ സ്റ്റാൻഡേർഡാണ്.

Red Hat AMQ ഓൺലൈൻ ഒരു ഓപ്പൺ സോഴ്സ് പ്രോജക്റ്റിന്റെ അടിസ്ഥാനത്തിൽ നിർമ്മിച്ച ഒരു സേവനമാണ് എൻമാസെ പ്ലാറ്റ്‌ഫോം അടിസ്ഥാനമാക്കിയുള്ള സന്ദേശമയയ്‌ക്കൽ സംവിധാനം നടപ്പിലാക്കുകയും ചെയ്യുന്നു Red Hat OpenShift. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, കാണുക ഇവിടെ (EN). രണ്ട് പുതിയ സന്ദേശമയയ്‌ക്കൽ സാങ്കേതികവിദ്യകൾ ഉപയോഗിച്ച് ഒരു ആധുനിക OpenShift-അധിഷ്‌ഠിത സന്ദേശമയയ്‌ക്കൽ സംവിധാനം നിർമ്മിക്കുന്നതിന് AMQ ഓൺലൈനും ക്വാർക്കസും എങ്ങനെ സംയോജിപ്പിക്കാമെന്ന് ഇന്ന് ഞങ്ങൾ നിങ്ങളെ കാണിച്ചുതരാം.

OpenShift പ്ലാറ്റ്‌ഫോമിൽ നിങ്ങൾ ഇതിനകം AMQ ഓൺലൈൻ വിന്യസിച്ചിട്ടുണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്നു (ഇല്ലെങ്കിൽ, കാണുക ഇൻസ്റ്റലേഷൻ ഗൈഡ്).

ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ ഒരു ക്വാർക്കസ് ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കും, അത് റിയാക്ടീവ് മെസേജിംഗ് ഉപയോഗിച്ച് ഒരു ലളിതമായ ഓർഡർ പ്രോസസ്സിംഗ് സിസ്റ്റം ആയിരിക്കും. ഒരു നിശ്ചിത ഇടവേളയിൽ സന്ദേശ ക്യൂവിലേക്ക് ഓർഡറുകൾ അയയ്‌ക്കുന്ന ഓർഡർ ജനറേറ്ററും ക്യൂവിൽ നിന്ന് സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുകയും ബ്രൗസറിൽ കാണാവുന്ന സ്ഥിരീകരണങ്ങൾ സൃഷ്‌ടിക്കുകയും ചെയ്യുന്ന ഒരു ഓർഡർ പ്രൊസസറും ഈ അപ്ലിക്കേഷനിൽ ഉൾപ്പെടും.

ഒരിക്കൽ ഞങ്ങൾ ആപ്ലിക്കേഷൻ സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, മെസേജിംഗ് സിസ്റ്റം കോൺഫിഗറേഷൻ ആപ്ലിക്കേഷനിലേക്ക് എങ്ങനെ എംബഡ് ചെയ്യാമെന്നും സിസ്റ്റത്തിൽ ഞങ്ങൾക്ക് ആവശ്യമായ വിഭവങ്ങൾ ലഭ്യമാക്കുന്നതിന് AMQ ഓൺലൈൻ ഉപയോഗിക്കാമെന്നും ഞങ്ങൾ നിങ്ങളെ കാണിക്കും.

ക്വാർക്കസ് ആപ്പ്

ഞങ്ങളുടെ ക്വാർക്കസ് ആപ്ലിക്കേഷൻ ഓപ്പൺഷിഫ്റ്റിൽ പ്രവർത്തിക്കുന്നു, ഇത് പ്രോഗ്രാമിന്റെ പരിഷ്കരിച്ച പതിപ്പാണ് amqp-ക്വിക്ക്സ്റ്റാർട്ട്. ക്ലയന്റ് വശത്തിന്റെ പൂർണ്ണമായ ഉദാഹരണം കണ്ടെത്താനാകും ഇവിടെ.

ഓർഡർ ജനറേറ്റർ

ഓരോ 5 സെക്കൻഡിലും "ഓർഡറുകൾ" എന്ന വിലാസത്തിലേക്ക് ജനറേറ്റർ ഏകതാനമായി വളരുന്ന ഓർഡർ ഐഡികൾ അയയ്ക്കുന്നു.

@ApplicationScoped
public class OrderGenerator {
 
    private int orderId = 1;
 
    @Outgoing("orders")
    public Flowable<Integer> generate() {
        return Flowable.interval(5, TimeUnit.SECONDS)
        .map(tick -> orderId++);
    }
}

ഓർഡർ പ്രോസസ്സർ

ഓർഡർ ഹാൻഡ്‌ലർ ഇതിലും ലളിതമാണ്, ഇത് "സ്ഥിരീകരണങ്ങൾ" വിലാസത്തിലേക്ക് ഒരു സ്ഥിരീകരണ ഐഡി നൽകുന്നു.

@ApplicationScoped
public class OrderProcessor {
    @Incoming("orders")
    @Outgoing("confirmations")
    public Integer process(Integer order) {
        // Идентификатор подтверждения равен удвоенному идентификатору заказа <img draggable="false" class="emoji" alt=":-)" src="https://s.w.org/images/core/emoji/11.2.0/svg/1f642.svg">
        return order * 2;
    }
}

സ്ഥിരീകരണ ഉറവിടങ്ങൾ

ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ സൃഷ്ടിച്ച സ്ഥിരീകരണങ്ങൾ ലിസ്റ്റുചെയ്യുന്നതിനുള്ള ഒരു HTTP എൻഡ്‌പോയിന്റാണ് സ്ഥിരീകരണ ഉറവിടം.

@Path("/confirmations")
public class ConfirmationResource {
 
    @Inject
    @Stream("confirmations") Publisher<Integer> orders;
 
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "hello";
    }
 
 
    @GET
    @Path("/stream")
    @Produces(MediaType.SERVER_SENT_EVENTS)
    public Publisher<Integer> stream() {
        return orders;
    }
}

കമപ്പെടുത്തല്

AMQ ഓൺലൈനിലേക്ക് കണക്റ്റുചെയ്യുന്നതിന്, ഞങ്ങളുടെ അപ്ലിക്കേഷന് ചില കോൺഫിഗറേഷൻ ഡാറ്റ ആവശ്യമാണ്, അതായത്: ക്വാർക്കസ് കണക്റ്റർ കോൺഫിഗറേഷൻ, AMQP എൻഡ്‌പോയിന്റ് വിവരങ്ങളും ക്ലയന്റ് ക്രെഡൻഷ്യലുകളും. തീർച്ചയായും, എല്ലാ കോൺഫിഗറേഷൻ ഡാറ്റയും ഒരിടത്ത് സൂക്ഷിക്കുന്നതാണ് നല്ലത്, എന്നാൽ ക്വാർക്കസ് ആപ്ലിക്കേഷൻ കോൺഫിഗർ ചെയ്യുന്നതിനുള്ള സാധ്യമായ ഓപ്ഷനുകൾ കാണിക്കുന്നതിന് ഞങ്ങൾ അവയെ മനഃപൂർവ്വം വേർതിരിക്കും.

കണക്ടറുകൾ

ഒരു ആപ്ലിക്കേഷൻ പ്രോപ്പർട്ടി ഫയൽ ഉപയോഗിച്ച് കംപൈൽ സമയത്ത് കണക്റ്റർ കോൺഫിഗറേഷൻ നൽകാം:

mp.messaging.outgoing.orders.connector=smallrye-amqp
mp.messaging.incoming.orders.connector=smallrye-amqp

കാര്യങ്ങൾ ലളിതമാക്കാൻ, "ഓർഡറുകൾ" വിലാസത്തിനായി ഞങ്ങൾ ഒരു സന്ദേശ ക്യൂ മാത്രമേ ഉപയോഗിക്കൂ. ഞങ്ങളുടെ ആപ്ലിക്കേഷനിലെ "സ്ഥിരീകരണങ്ങൾ" വിലാസം മെമ്മറിയിൽ ഒരു ക്യൂ ഉപയോഗിക്കും.

AMQP അവസാന പോയിന്റ്

കംപൈൽ സമയത്ത്, AMQP എൻഡ്‌പോയിന്റിനായുള്ള ഹോസ്റ്റ്നാമവും പോർട്ട് നമ്പറും അജ്ഞാതമാണ്, അതിനാൽ അവ കുത്തിവയ്ക്കണം. AMQ ഓൺലൈൻ സൃഷ്‌ടിച്ച കോൺഫിഗ്‌മാപ്പിൽ എൻഡ്‌പോയിന്റ് സജ്ജീകരിക്കാൻ കഴിയും, അതിനാൽ ആപ്ലിക്കേഷൻ മാനിഫെസ്റ്റിലെ എൻവയോൺമെന്റ് വേരിയബിളുകൾ വഴി ഞങ്ങൾ അവയെ നിർവ്വചിക്കും:

spec:
  template:
    spec:
      containers:
      - env:
        - name: AMQP_HOST
          valueFrom:
            configMapKeyRef:
              name: quarkus-config
              key: service.host
        - name: AMQP_PORT
          valueFrom:
            configMapKeyRef:
              name: quarkus-config
              key: service.port.amqp

ക്രെഡൻഷ്യലുകൾ

ഓപ്പൺഷിഫ്റ്റിലേക്കുള്ള ഞങ്ങളുടെ അപേക്ഷ ആധികാരികമാക്കാൻ സേവന അക്കൗണ്ട് ടോക്കൺ ഉപയോഗിക്കാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ആദ്യം പോഡിന്റെ ഫയൽ സിസ്റ്റത്തിൽ നിന്ന് പ്രാമാണീകരണ ടോക്കൺ വായിക്കുന്ന ഒരു ഇഷ്‌ടാനുസൃത കോൺഫിഗറേഷൻ സോഴ്‌സ് സൃഷ്‌ടിക്കണം:

public class MessagingCredentialsConfigSource implements ConfigSource {
    private static final Set<String> propertyNames;
 
    static {
        propertyNames = new HashSet<>();
        propertyNames.add("amqp-username");
        propertyNames.add("amqp-password");
    }
 
    @Override
    public Set<String> getPropertyNames() {
        return propertyNames;
    }
 
    @Override
    public Map<String, String> getProperties() {
        try {
            Map<String, String> properties = new HashMap<>();
            properties.put("amqp-username", "@@serviceaccount@@");
            properties.put("amqp-password", readTokenFromFile());
            return properties;
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
 
    @Override
    public String getValue(String key) {
        if ("amqp-username".equals(key)) {
            return "@@serviceaccount@@";
        }
        if ("amqp-password".equals(key)) {
            try {
                return readTokenFromFile();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
        return null;
    }
 
    @Override
    public String getName() {
        return "messaging-credentials-config";
    }
 
    private static String readTokenFromFile() throws IOException {
        return new String(Files.readAllBytes(Paths.get("/var/run/secrets/kubernetes.io/serviceaccount/token")), StandardCharsets.UTF_8);
    }
}

ആപ്ലിക്കേഷൻ നിർമ്മിക്കുകയും വിന്യസിക്കുകയും ചെയ്യുക

ആപ്ലിക്കേഷൻ ഒരു എക്സിക്യൂട്ടബിൾ ഫയലിലേക്ക് കംപൈൽ ചെയ്യേണ്ടതിനാൽ, ഒരു GraalVM വെർച്വൽ മെഷീൻ ആവശ്യമാണ്. ഇതിനുള്ള ഒരു പരിസ്ഥിതി എങ്ങനെ സജ്ജീകരിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക്, അനുബന്ധ നിർദ്ദേശങ്ങൾ കാണുക ക്വാർക്കസ് ഗൈഡ്.

തുടർന്ന്, അവിടെ നൽകിയിരിക്കുന്ന നിർദ്ദേശങ്ങൾ പാലിച്ച്, നിങ്ങൾ ഉറവിടം ഡൗൺലോഡ് ചെയ്യുകയും ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ നിർമ്മിക്കുകയും വിന്യസിക്കുകയും ചെയ്യേണ്ടതുണ്ട്:

git clone https://github.com/EnMasseProject/enmasse-example-clients
cd enmasse-example-clients/quarkus-example-client
oc new-project myapp
mvn -Pnative -Dfabric8.mode=openshift -Dfabric8.build.strategy=docker package fabric8:build fabric8:resource fabric8:apply

ഈ കമാൻഡുകൾക്ക് ശേഷം, ആപ്ലിക്കേഷൻ വിന്യസിക്കും, എന്നാൽ AMQ ഓൺലൈനിൽ ഞങ്ങൾക്ക് ആവശ്യമായ സന്ദേശമയയ്‌ക്കൽ ഉറവിടങ്ങൾ കോൺഫിഗർ ചെയ്യുന്നതുവരെ ആരംഭിക്കില്ല.

സന്ദേശമയയ്‌ക്കൽ സംവിധാനം സജ്ജീകരിക്കുന്നു

ഇപ്പോൾ അവശേഷിക്കുന്നത് സന്ദേശമയയ്‌ക്കൽ സിസ്റ്റത്തിൽ ഞങ്ങളുടെ അപ്ലിക്കേഷന് ആവശ്യമായ ഉറവിടങ്ങൾ സജ്ജമാക്കുക എന്നതാണ്. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ സൃഷ്ടിക്കേണ്ടതുണ്ട്: 1) സന്ദേശമയയ്‌ക്കൽ സിസ്റ്റം എൻഡ്‌പോയിന്റ് ആരംഭിക്കുന്നതിനുള്ള ഒരു വിലാസ ഇടം; 2) ഞങ്ങൾ ആപ്ലിക്കേഷനിൽ ഉപയോഗിക്കുന്ന വിലാസങ്ങൾ കോൺഫിഗർ ചെയ്യുന്നതിനുള്ള വിലാസം; 3) ക്ലയന്റ് ക്രെഡൻഷ്യലുകൾ സജ്ജമാക്കാൻ ഉപയോക്താവിന് സന്ദേശമയയ്‌ക്കൽ.

വിലാസ സ്ഥലം

AMQ ഓൺലൈനിലെ ഒരു അഡ്രസ്‌സ്‌പേസ് ഒബ്‌ജക്റ്റ് എന്നത് കണക്ഷൻ എൻഡ്‌പോയിന്റുകളും പ്രാമാണീകരണ, അംഗീകാര നയങ്ങളും പങ്കിടുന്ന ഒരു കൂട്ടം വിലാസങ്ങളാണ്. നിങ്ങൾ ഒരു വിലാസ ഇടം സൃഷ്‌ടിക്കുമ്പോൾ, സന്ദേശമയയ്‌ക്കൽ എൻഡ്‌പോയിന്റുകൾ എങ്ങനെ തുറന്നുകാട്ടപ്പെടുമെന്ന് നിങ്ങൾക്ക് വ്യക്തമാക്കാം:

apiVersion: enmasse.io/v1beta1
kind: AddressSpace
metadata:
  name: quarkus-example
spec:
  type: brokered
  plan: brokered-single-broker
  endpoints:
  - name: messaging
    service: messaging
    exports:
    - name: quarkus-config
      kind: configmap

വിലാസങ്ങൾ

സന്ദേശങ്ങൾ അയക്കാനും സ്വീകരിക്കാനും വിലാസങ്ങൾ ഉപയോഗിക്കുന്നു. ഓരോ വിലാസത്തിനും ഒരു തരം ഉണ്ട്, അത് അതിന്റെ സെമാന്റിക്സിനെ നിർണ്ണയിക്കുന്നു, അതുപോലെ തന്നെ റിസർവ് ചെയ്യേണ്ട വിഭവങ്ങളുടെ എണ്ണം വ്യക്തമാക്കുന്ന ഒരു പ്ലാനും. വിലാസം നിർണ്ണയിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ഇതുപോലെ:

apiVersion: enmasse.io/v1beta1
kind: Address
metadata:
  name: quarkus-example.orders
spec:
  address: orders
  type: queue
  plan: brokered-queue

സന്ദേശമയയ്‌ക്കൽ ഉപയോക്താവ്

വിശ്വസനീയമായ ആപ്ലിക്കേഷനുകൾക്ക് മാത്രമേ നിങ്ങളുടെ വിലാസങ്ങളിലേക്ക് സന്ദേശങ്ങൾ അയയ്‌ക്കാനും സ്വീകരിക്കാനും കഴിയൂ എന്ന് ഉറപ്പാക്കാൻ, നിങ്ങൾ സന്ദേശമയയ്‌ക്കൽ സംവിധാനത്തിൽ ഒരു ഉപയോക്താവിനെ സൃഷ്‌ടിക്കണം. ഒരു ക്ലസ്റ്ററിൽ പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനുകൾക്കായി, ഒരു ഓപ്പൺഷിഫ്റ്റ് സേവന അക്കൗണ്ട് ഉപയോഗിച്ച് ക്ലയന്റുകളെ പ്രാമാണീകരിക്കാൻ കഴിയും. "സർവീസ് അക്കൗണ്ട്" എന്ന ഉപയോക്താവിനെ നിർവചിക്കാം, ഉദാഹരണത്തിന്, ഇതുപോലെ:

apiVersion: user.enmasse.io/v1beta1
kind: MessagingUser
metadata:
  name: quarkus-example.app
spec:
  username: system:serviceaccount:myapp:default
  authentication:
    type: serviceaccount
  authorization:
  - operations: ["send", "recv"]
    addresses: ["orders"]

ആപ്ലിക്കേഷൻ കോൺഫിഗർ ചെയ്യുന്നതിനുള്ള അനുമതികൾ

AMQP എൻഡ്‌പോയിന്റ് വിവരങ്ങൾ ഉൾച്ചേർക്കാൻ ഞങ്ങൾ ഉപയോഗിച്ച കോൺഫിഗ്‌മാപ്പ് AMQ ഓൺലൈനായി സൃഷ്‌ടിക്കുന്നതിന്, റോളും റോൾബൈൻഡിംഗും സജ്ജീകരിക്കേണ്ടതുണ്ട്:

---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: quarkus-config
spec:
  rules:
  - apiGroups: [ "" ]
    resources: [ "configmaps" ]
    verbs: [ "create" ]
  - apiGroups: [ "" ]
    resources: [ "configmaps" ]
    resourceNames: [ "quarkus-config" ]
    verbs: [ "get", "update", "patch" ]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: quarkus-config
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: quarkus-config
subjects:
- kind: ServiceAccount
  name: address-space-controller
  namespace: amq-online-infra

കോൺഫിഗറേഷനുകൾ എങ്ങനെ പ്രയോഗിക്കാം

നിങ്ങൾക്ക് സന്ദേശമയയ്‌ക്കൽ സിസ്റ്റം കോൺഫിഗറേഷൻ ഇതുപോലെ പ്രയോഗിക്കാൻ കഴിയും:

cd enmasse-example-clients/quarkus-example-client
oc project myapp
oc apply -f src/main/resources/k8s/addressspace
oc apply -f src/main/resources/k8s/address

അപേക്ഷ പരിശോധിച്ചുറപ്പിക്കൽ

ആപ്ലിക്കേഷൻ ആരംഭിച്ചുവെന്ന് ഉറപ്പാക്കാൻ, ഒന്നാമതായി, അനുബന്ധ വിലാസങ്ങൾ സൃഷ്ടിച്ചിട്ടുണ്ടോ എന്നും സജീവമാണോ എന്ന് പരിശോധിക്കാം:

until [[ `oc get address quarkus-example.prices -o jsonpath='{.status.phase}'` == "Active" ]]; do echo "Not yet ready"; sleep 5; done

അപ്പോൾ നമുക്ക് ആപ്ലിക്കേഷൻ റൂട്ട് URL പരിശോധിക്കാം (ബ്രൗസറിൽ ഈ വിലാസം തുറക്കുക):

echo "http://$(oc get route quarkus-example-client -o jsonpath='{.spec.host}')/prices.html"

AMQ ഓൺലൈനിൽ സന്ദേശങ്ങൾ അയയ്ക്കുകയും സ്വീകരിക്കുകയും ചെയ്യുന്നതിനാൽ ടിക്കറ്റുകൾ കാലാകാലങ്ങളിൽ അപ്ഡേറ്റ് ചെയ്യപ്പെടുന്നുവെന്ന് ബ്രൗസർ കാണിക്കണം.

സംഗ്രഹിക്കുന്നു

അതിനാൽ ഞങ്ങൾ സന്ദേശമയയ്‌ക്കുന്നതിനായി AMQP ഉപയോഗിക്കുന്ന ഒരു ക്വാർക്കസ് ആപ്ലിക്കേഷൻ എഴുതി, Red Hat OpenShift പ്ലാറ്റ്‌ഫോമിൽ പ്രവർത്തിക്കാൻ ആപ്ലിക്കേഷൻ ക്രമീകരിച്ചു, AMQ ഓൺലൈൻ കോൺഫിഗറേഷൻ അടിസ്ഥാനമാക്കി അതിന്റെ കോൺഫിഗറേഷൻ നടപ്പിലാക്കി. ഞങ്ങളുടെ ആപ്ലിക്കേഷനായി സന്ദേശമയയ്‌ക്കൽ സംവിധാനം ആരംഭിക്കുന്നതിന് ആവശ്യമായ മാനിഫെസ്റ്റുകൾ ഞങ്ങൾ സൃഷ്‌ടിച്ചു.

ഇത് ക്വാർക്കസിനെക്കുറിച്ചുള്ള പരമ്പര അവസാനിപ്പിക്കുന്നു, എന്നാൽ പുതിയതും രസകരവുമായ ഒരുപാട് കാര്യങ്ങൾ മുന്നിലുണ്ട്, തുടരുക!

അവലംബം: www.habr.com