For network automation, I see that NETCONF, RESTCONF and gRPC are available. Can someone tell me which one should be chosen for a typical router and respective use cases.
Can you please share the known issues or challenges with respective approach in terms of implementation.
Related
Today I have a bit tricky question. Imagine a situation when someone has written a custom connector to the network (let's say there are a lot of security features hidden and so on). Now imagine that each application can connect to the network (even IoT Edge Runtime) only through this custom connector (let's say, this connector has implementation of both https and plain MQTT protocols).
Now the issue! According to the documentation here https://github.com/Azure/iotedge/blob/master/doc/networking.md the IoT Edge Runtime connects to the network through moby-engine modified by Microsoft. According to the Microsoft, we cannot get this moby-engine. Moreover, if we use original moby project the support from the Microsoft will be caught off, which is a bad thing. So, we cannot modify moby-engine and make it use this custom connector.
Now the question!
Is it possible (may be I missed something in documentation. Not the first time tbh) to use custom connector with IoT Edge Runtime (no proxy, we need plain MQTT protocol)? If yes, can you explain in details how? If no, what posible features inside Iot Edge Runtime/moby engine can help to use custom connector?
Please ask, if you need more information. I will provide it right away. A similar question was asked by me on Microsoft github. No response from there.
The proposal from #silent pointed me to the correct direction. While reading manuals, how to properly setup a gateway, I once again began to read manual about creating custom modules. This pointed me to have a look at preparing a build environment. This again directed me to the SDK bit.
Honestly speaking, by accident and mostly out of curiosity I clicked the link about porting the SDK to my custom platform. This was the solution in my case https://github.com/Azure/azure-c-shared-utility/blob/master/devdoc/porting_guide.md
I have to mention here two other solutions I walked through:
Proxy server that supports your custom connector/protocol (will
work for cases where you do not need MQTT. However, MQTT websockets
can be used here)
Gateway. This is definitely a good one. Again many thanks to #silent.
Which one will work in your particular case is only up to you to decide.
This is a basic questions. I want to apply to an entry level java developer position with the following requirement:
Familiarity with the Sailpoint Identity IQ standard adapters/connectors
By standard connectors do they basically mean how Sailpoint exchanges data with third party tools? And by adapter do they mean that the adapter pattern would be used? Thanks
This is going to probably appear well after your interview - but to answer the question:
1) Standard adapters/connectors:
SailPoint ships with a "standard" set of connectors which are part of the purchase price there are those ie EPIC which do not ship as part of the standard product and must be enabled. To give you a deeper view into connectors..
Connectivity Methods:
Direct Connectivity - This is where a connector communicates directly to a system using APIs or data-sources. Some advantages of using direct connect are that you don't have to generate or transmit files, and you can be more efficient in processing only things that have changed. Some disadvantages are the they are subject to availability and downtime concerns like any connected system. They are also typically subject to advantages and disadvantages that APIs might impose as well.
Some people also refer to this as an 'online' method of connectivity.
File-Based Connectivity - This is where a connector reads from a snapshot of data presented in a file, rather than connecting directly to the system. Some advantages of using a file, are that files are portable, easily inspected for data issues, and not typically subject to availability. Some disadvantages are that files are usually processed in their entirety, and may require processing or transformation in order to work effectively.
Some people also refer to this as a 'decoupled' or 'offline' method of connectivity.
Connector Implementations
Source-Specific Implementation - These are connectors built with a specific target-system in mind. These typically use specific APIs targeted to the system they are integrated with. Because the systems and APIs are known, these typically require less configurations to get working.
Examples of these are Active Directory, Workday, Salesforce, SAP, etc.
General Implementation - These are general-purpose connectors which can be used to connect to a variety of sources or systems. These tend to be more flexible in general, but typically do require a bit more setup and configuration to meet needs.
Examples of these are Web Services, SCIM, JDBC, Delimited Files, etc.
Custom Implementation - These are completely custom connectors and tailored to the system and API of your choice. This approach offers the most flexibility of all connector options, however making custom connectors is definitely a development-level activity, and is not to be taken lightly. The code written for custom connectors is maintained and supported by the customer who owns the connector.
Examples of these are custom in-house applications, etc.
Understanding these connector implementations is important, because if a source-specific implementation isn't available, another general or custom connector implementation may be used instead.
I am totally new to Solace, your ideas will be grateful. building a system that will integrate with Solace Messaging bus. the system will have a service layer which will communicate with Solace Messaging bus to pull messages from external systems and in future, it also will be integrate with internet based messages.
So I have two options in front of me, 1) JMS 2) .NET 3) REST
Could you please let me know which is the best option above, when the service layer has to connect with .NET Business layer. considering, extensibility, performance, message transformation, scalability etc.,
Thanks
Messages are generally inter-operable between the different APIs.
For example, a JMS message can be consumed by a .NET consumer.
You can pick whichever API is the most convenient for your use case.
Since your service layer is communicating directly with your .NET Business layer, perhaps it might make sense to have the service layer use the .NET API.
Alternatively, you might feel that it makes sense to make use of the REST API, which is an open protocol, without the need for Solace provided libraries.
I have a fairly complex windows service (written in .net 4) with several sub systems that run in parallel.
I have implemented pretty good logging throughout, but I'm feeling I'm needing more info about what each subsystem is currently doing. This would be very useful for times that I need to stop the service for upgrade/bug fixes.
It would be nice to have a gui app that will show me the status for each part of the application that I'm interested in. I've had some ideas for how I'm going to do this, but I'd like to hear some others' ideas as well.
I'm interested in a solution that would be easy to plop down in a future windows service and I'm not looking for anything very complex.
Are there any tools for this sort of thing?
Have you done this yourself?
What about interprocess communication?
Since Windows services can no longer interact with the user session, you'll need to have a separate application that does the interacting for you. Based on the details of your question, I think you understand this.
The big question is how to facilitate the communication between your Windows service and the application. There are all kinds of approaches - shared memory, socket, pipe, remoting, etc. What I have used successfully is WCF. If your UI is going to reside on the same machine as the service, use the NetNamedPipeBinding. If you ever need access from a remote machine, you can change to the NetTcpBinding. I've found this flow chart helpful in binding selection.
.
If you're looking for a more formal framework approach that just straight WCF, have a look at Juval Lowy's Publish-Subscribe WCF Framework, which is described in pretty good detail in this MSDN article. The code is available to look at via the article, or you can download the source and example from Lowy's website here. Go to the Downloads section, filter by the Discovery category, and you'll see it there.
I want to know what is the difference between these two implementations of neo4j. Of-course names of both techniques is self-explanatory,but still what are the main differences?
What factors should be considered in deciding which technique to use in the project?
Pros and cons.
P.S. Sorry if it is a repeat question but I searched and was not able to find any ques which answers my question.
Because the standalone server is built on the embedded server, the general rule of thumb is that the embedded server is more capable and has (obviously) lower latency. Either can operate in High-Availability mode, allow monitoring, and even accept connections from the neo4j-shell. With the server though, you get more functionality out-of-the-box, like remoting, basic visualization, monitoring interface, etc.
The differences are otherwise the practical ones you'd imagine. Choosing a deployment approach is influenced by two things:
Language - embedded mode requires that you're implementing your application with a JVM compatible language. The server supports any language/framework that can send HTTP requests.
Hardware - sharing physical resources between your application and Neo4j can be demanding. Scaling may argue for a dedicated machine to split out the persistence layer. The server obviously has a remote API to support segmenting your application.
It's otherwise difficult to give guidance without a specific usage scenario. Deploying into an existing Service Oriented Architecture? Probably server. Running on an copier machine? Go embedded. From scratch web application? What's the rest of your stack?